LCOV - code coverage report
Current view: top level - cppuhelper/source - factory.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 53 315 16.8 %
Date: 2014-04-14 Functions: 19 65 29.2 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <osl/diagnose.h>
      21             : #include <osl/mutex.hxx>
      22             : #include <cppuhelper/weak.hxx>
      23             : #include <cppuhelper/bootstrap.hxx>
      24             : #include <cppuhelper/component.hxx>
      25             : #include <cppuhelper/factory.hxx>
      26             : #include <cppuhelper/implbase3.hxx>
      27             : #include <cppuhelper/shlib.hxx>
      28             : #include <cppuhelper/supportsservice.hxx>
      29             : #include <cppuhelper/typeprovider.hxx>
      30             : #include <rtl/instance.hxx>
      31             : #include <rtl/unload.h>
      32             : 
      33             : #include "cppuhelper/propshlp.hxx"
      34             : 
      35             : #include <com/sun/star/lang/XServiceInfo.hpp>
      36             : #include <com/sun/star/lang/XSingleServiceFactory.hpp>
      37             : #include <com/sun/star/lang/XSingleComponentFactory.hpp>
      38             : #include <com/sun/star/lang/XInitialization.hpp>
      39             : #include <com/sun/star/loader/XImplementationLoader.hpp>
      40             : #include <com/sun/star/lang/XComponent.hpp>
      41             : #include <com/sun/star/lang/IllegalArgumentException.hpp>
      42             : #include <com/sun/star/uno/XUnloadingPreference.hpp>
      43             : #include "com/sun/star/beans/PropertyAttribute.hpp"
      44             : 
      45             : #include <memory>
      46             : 
      47             : 
      48             : using namespace osl;
      49             : using namespace com::sun::star;
      50             : using namespace com::sun::star::uno;
      51             : using namespace com::sun::star::lang;
      52             : using namespace com::sun::star::loader;
      53             : using namespace com::sun::star::registry;
      54             : 
      55             : using ::rtl::OUString;
      56             : 
      57             : namespace cppu
      58             : {
      59             : 
      60             : class OSingleFactoryHelper
      61             :     : public XServiceInfo
      62             :     , public XSingleServiceFactory
      63             :     , public lang::XSingleComponentFactory
      64             :     , public XUnloadingPreference
      65             : {
      66             : public:
      67           5 :     OSingleFactoryHelper(
      68             :         const Reference<XMultiServiceFactory > & rServiceManager,
      69             :         const OUString & rImplementationName_,
      70             :         ComponentInstantiation pCreateFunction_,
      71             :         ComponentFactoryFunc fptr,
      72             :         const Sequence< OUString > * pServiceNames_ )
      73             :         SAL_THROW(())
      74             :         : xSMgr( rServiceManager )
      75             :         , pCreateFunction( pCreateFunction_ )
      76             :         , m_fptr( fptr )
      77           5 :         , aImplementationName( rImplementationName_ )
      78             :         {
      79           5 :             if( pServiceNames_ )
      80           5 :                 aServiceNames = *pServiceNames_;
      81           5 :         }
      82             : 
      83             :     virtual ~OSingleFactoryHelper();
      84             : 
      85             :     // XInterface
      86             :     Any SAL_CALL queryInterface( const Type & rType )
      87             :         throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      88             : 
      89             :     // XSingleServiceFactory
      90             :     Reference<XInterface > SAL_CALL createInstance()
      91             :         throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      92             :     virtual Reference<XInterface > SAL_CALL createInstanceWithArguments(const Sequence<Any>& Arguments)
      93             :         throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      94             :     // XSingleComponentFactory
      95             :     virtual Reference< XInterface > SAL_CALL createInstanceWithContext(
      96             :         Reference< XComponentContext > const & xContext )
      97             :         throw (Exception, RuntimeException, std::exception) SAL_OVERRIDE;
      98             :     virtual Reference< XInterface > SAL_CALL createInstanceWithArgumentsAndContext(
      99             :         Sequence< Any > const & rArguments,
     100             :         Reference< XComponentContext > const & xContext )
     101             :         throw (Exception, RuntimeException, std::exception) SAL_OVERRIDE;
     102             : 
     103             :     // XServiceInfo
     104             :     OUString SAL_CALL getImplementationName()
     105             :         throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     106             :     sal_Bool SAL_CALL supportsService(const OUString& ServiceName)
     107             :         throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     108             :     Sequence< OUString > SAL_CALL getSupportedServiceNames(void)
     109             :         throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     110             : 
     111             : protected:
     112             :     /**
     113             :      * Create an instance specified by the factory. The one instance logic is implemented
     114             :      * in the createInstance and createInstanceWithArguments methods.
     115             :      * @return the newly created instance. Do not return a previous (one instance) instance.
     116             :      */
     117             :     virtual Reference<XInterface >  createInstanceEveryTime(
     118             :         Reference< XComponentContext > const & xContext )
     119             :         throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
     120             : 
     121             :     Reference<XMultiServiceFactory > xSMgr;
     122             :     ComponentInstantiation           pCreateFunction;
     123             :     ComponentFactoryFunc             m_fptr;
     124             :     Sequence< OUString >             aServiceNames;
     125             :     OUString                         aImplementationName;
     126             : };
     127           5 : OSingleFactoryHelper::~OSingleFactoryHelper()
     128             : {
     129           5 : }
     130             : 
     131             : 
     132             : 
     133           4 : Any OSingleFactoryHelper::queryInterface( const Type & rType )
     134             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     135             : {
     136             :     return ::cppu::queryInterface(
     137             :         rType,
     138             :         static_cast< XSingleComponentFactory * >( this ),
     139             :         static_cast< XSingleServiceFactory * >( this ),
     140             :         static_cast< XServiceInfo * >( this ) ,
     141           4 :         static_cast< XUnloadingPreference * >( this ));
     142             : }
     143             : 
     144             : // OSingleFactoryHelper
     145           5 : Reference<XInterface > OSingleFactoryHelper::createInstanceEveryTime(
     146             :     Reference< XComponentContext > const & xContext )
     147             :     throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException)
     148             : {
     149           5 :     if (m_fptr)
     150             :     {
     151           5 :         return (*m_fptr)( xContext );
     152             :     }
     153           0 :     else if( pCreateFunction )
     154             :     {
     155           0 :         if (xContext.is())
     156             :         {
     157             :             Reference< lang::XMultiServiceFactory > xContextMgr(
     158           0 :                 xContext->getServiceManager(), UNO_QUERY );
     159           0 :             if (xContextMgr.is())
     160           0 :                 return (*pCreateFunction)( xContextMgr );
     161             :         }
     162           0 :         return (*pCreateFunction)( xSMgr );
     163             :     }
     164             :     else
     165             :     {
     166           0 :         return Reference< XInterface >();
     167             :     }
     168             : }
     169             : 
     170             : // XSingleServiceFactory
     171           0 : Reference<XInterface > OSingleFactoryHelper::createInstance()
     172             :     throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException, std::exception)
     173             : {
     174           0 :     return createInstanceWithContext( Reference< XComponentContext >() );
     175             : }
     176             : 
     177             : // XSingleServiceFactory
     178           0 : Reference<XInterface > OSingleFactoryHelper::createInstanceWithArguments(
     179             :     const Sequence<Any>& Arguments )
     180             :     throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException, std::exception)
     181             : {
     182             :     return createInstanceWithArgumentsAndContext(
     183           0 :         Arguments, Reference< XComponentContext >() );
     184             : }
     185             : 
     186             : // XSingleComponentFactory
     187             : 
     188           5 : Reference< XInterface > OSingleFactoryHelper::createInstanceWithContext(
     189             :     Reference< XComponentContext > const & xContext )
     190             :     throw (Exception, RuntimeException, std::exception)
     191             : {
     192           5 :     return createInstanceEveryTime( xContext );
     193             : }
     194             : 
     195           3 : Reference< XInterface > OSingleFactoryHelper::createInstanceWithArgumentsAndContext(
     196             :     Sequence< Any > const & rArguments,
     197             :     Reference< XComponentContext > const & xContext )
     198             :     throw (Exception, RuntimeException, std::exception)
     199             : {
     200           3 :     Reference< XInterface > xRet( createInstanceWithContext( xContext ) );
     201             : 
     202           6 :     Reference< lang::XInitialization > xInit( xRet, UNO_QUERY );
     203             :     // always call initialize, even if there are no arguments.
     204             :     // #i63511# / 2006-03-27 / frank.schoenheit@sun.com
     205           3 :     if (xInit.is())
     206             :     {
     207           3 :         xInit->initialize( rArguments );
     208             :     }
     209             :     else
     210             :     {
     211           0 :         if ( rArguments.getLength() )
     212             :         {
     213             :             // dispose the here created UNO object before throwing out exception
     214             :             // to avoid risk of memory leaks #i113722#
     215           0 :             Reference<XComponent> xComp( xRet, UNO_QUERY );
     216           0 :             if (xComp.is())
     217           0 :                 xComp->dispose();
     218             : 
     219             :             throw lang::IllegalArgumentException(
     220             :                 OUString("cannot pass arguments to component => no XInitialization implemented!"),
     221           0 :                 Reference< XInterface >(), 0 );
     222             :         }
     223             :     }
     224             : 
     225           6 :     return xRet;
     226             : }
     227             : 
     228             : // XServiceInfo
     229           0 : OUString OSingleFactoryHelper::getImplementationName()
     230             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     231             : {
     232           0 :     return aImplementationName;
     233             : }
     234             : 
     235             : // XServiceInfo
     236           0 : sal_Bool OSingleFactoryHelper::supportsService(
     237             :     const OUString& ServiceName )
     238             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     239             : {
     240           0 :     return cppu::supportsService(this, ServiceName);
     241             : }
     242             : 
     243             : // XServiceInfo
     244           0 : Sequence< OUString > OSingleFactoryHelper::getSupportedServiceNames(void)
     245             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     246             : {
     247           0 :     return aServiceNames;
     248             : }
     249             : 
     250          10 : struct OFactoryComponentHelper_Mutex
     251             : {
     252             :     Mutex   aMutex;
     253             : };
     254             : 
     255          10 : class OFactoryComponentHelper
     256             :     : public OFactoryComponentHelper_Mutex
     257             :     , public OComponentHelper
     258             :     , public OSingleFactoryHelper
     259             : {
     260             : public:
     261           5 :     OFactoryComponentHelper(
     262             :         const Reference<XMultiServiceFactory > & rServiceManager,
     263             :         const OUString & rImplementationName_,
     264             :         ComponentInstantiation pCreateFunction_,
     265             :         ComponentFactoryFunc fptr,
     266             :         const Sequence< OUString > * pServiceNames_,
     267             :         bool bOneInstance_ = false )
     268             :         SAL_THROW(())
     269             :         : OComponentHelper( aMutex )
     270             :         , OSingleFactoryHelper( rServiceManager, rImplementationName_, pCreateFunction_, fptr, pServiceNames_ )
     271           5 :         , bOneInstance( bOneInstance_ )
     272             :         {
     273           5 :         }
     274             : 
     275             :     // XInterface
     276             :     Any SAL_CALL queryInterface( const Type & rType )
     277             :         throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     278          60 :     void SAL_CALL acquire() throw() SAL_OVERRIDE
     279          60 :         { OComponentHelper::acquire(); }
     280          60 :     void SAL_CALL release() throw() SAL_OVERRIDE
     281          60 :         { OComponentHelper::release(); }
     282             : 
     283             :     // XSingleServiceFactory
     284             :     Reference<XInterface > SAL_CALL createInstance()
     285             :         throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     286             :     Reference<XInterface > SAL_CALL createInstanceWithArguments( const Sequence<Any>& Arguments )
     287             :         throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     288             :     // XSingleComponentFactory
     289             :     virtual Reference< XInterface > SAL_CALL createInstanceWithContext(
     290             :         Reference< XComponentContext > const & xContext )
     291             :         throw (Exception, RuntimeException, std::exception) SAL_OVERRIDE;
     292             :     virtual Reference< XInterface > SAL_CALL createInstanceWithArgumentsAndContext(
     293             :         Sequence< Any > const & rArguments,
     294             :         Reference< XComponentContext > const & xContext )
     295             :         throw (Exception, RuntimeException, std::exception) SAL_OVERRIDE;
     296             : 
     297             :     // XTypeProvider
     298             :     virtual Sequence< Type > SAL_CALL getTypes() throw (::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     299             :     virtual Sequence< sal_Int8 > SAL_CALL getImplementationId() throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     300             : 
     301             :     // XAggregation
     302             :     Any SAL_CALL queryAggregation( const Type & rType )
     303             :         throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     304             : 
     305             :     // XUnloadingPreference
     306             :     virtual sal_Bool SAL_CALL releaseOnNotification()
     307             :         throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     308             : 
     309             :     // OComponentHelper
     310             :     void SAL_CALL dispose() throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     311             : 
     312             : private:
     313             :     Reference<XInterface >  xTheInstance;
     314             :     bool                bOneInstance;
     315             : protected:
     316             :     // needed for implementing XUnloadingPreference in inheriting classes
     317           0 :     bool isOneInstance() {return bOneInstance;}
     318           0 :     bool isInstance() {return xTheInstance.is();}
     319             : };
     320             : 
     321             : 
     322          10 : Any SAL_CALL OFactoryComponentHelper::queryInterface( const Type & rType )
     323             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     324             : {
     325          10 :     if( rType == ::getCppuType( (Reference<XUnloadingPreference>*)0))
     326             :     {
     327             :         return makeAny(
     328             :             Reference< XUnloadingPreference >(
     329           0 :                 static_cast< XUnloadingPreference * >(this) ) );
     330             :     }
     331          10 :     return OComponentHelper::queryInterface( rType );
     332             : }
     333             : 
     334             : // XAggregation
     335          10 : Any OFactoryComponentHelper::queryAggregation( const Type & rType )
     336             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     337             : {
     338          10 :     Any aRet( OComponentHelper::queryAggregation( rType ) );
     339          10 :     return (aRet.hasValue() ? aRet : OSingleFactoryHelper::queryInterface( rType ));
     340             : }
     341             : 
     342             : // XTypeProvider
     343           0 : Sequence< Type > OFactoryComponentHelper::getTypes()
     344             :     throw (::com::sun::star::uno::RuntimeException, std::exception)
     345             : {
     346           0 :     Type ar[ 4 ];
     347           0 :     ar[ 0 ] = ::getCppuType( (const Reference< XSingleServiceFactory > *)0 );
     348           0 :     ar[ 1 ] = ::getCppuType( (const Reference< XServiceInfo > *)0 );
     349           0 :     ar[ 2 ] = ::getCppuType( (const Reference< XUnloadingPreference > *)0 );
     350             : 
     351           0 :     if (m_fptr)
     352           0 :         ar[ 3 ] = ::getCppuType( (const Reference< XSingleComponentFactory > *)0 );
     353             : 
     354           0 :     return Sequence< Type >( ar, m_fptr ? 4 : 3 );
     355             : }
     356             : 
     357           0 : Sequence< sal_Int8 > OFactoryComponentHelper::getImplementationId()
     358             :     throw (::com::sun::star::uno::RuntimeException, std::exception)
     359             : {
     360           0 :     return css::uno::Sequence<sal_Int8>();
     361             : }
     362             : 
     363             : // XSingleServiceFactory
     364           0 : Reference<XInterface > OFactoryComponentHelper::createInstance()
     365             :     throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException, std::exception)
     366             : {
     367           0 :     if( bOneInstance )
     368             :     {
     369           0 :         if( !xTheInstance.is() )
     370             :         {
     371           0 :             MutexGuard aGuard( aMutex );
     372           0 :             if( !xTheInstance.is() )
     373           0 :                 xTheInstance = OSingleFactoryHelper::createInstance();
     374             :         }
     375           0 :         return xTheInstance;
     376             :     }
     377           0 :     return OSingleFactoryHelper::createInstance();
     378             : }
     379             : 
     380           0 : Reference<XInterface > OFactoryComponentHelper::createInstanceWithArguments(
     381             :     const Sequence<Any>& Arguments )
     382             :     throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException, std::exception)
     383             : {
     384           0 :     if( bOneInstance )
     385             :     {
     386           0 :         if( !xTheInstance.is() )
     387             :         {
     388           0 :             MutexGuard aGuard( aMutex );
     389             : //          OSL_ENSURE( !xTheInstance.is(), "### arguments will be ignored!" );
     390           0 :             if( !xTheInstance.is() )
     391           0 :                 xTheInstance = OSingleFactoryHelper::createInstanceWithArguments( Arguments );
     392             :         }
     393           0 :         return xTheInstance;
     394             :     }
     395           0 :     return OSingleFactoryHelper::createInstanceWithArguments( Arguments );
     396             : }
     397             : 
     398             : // XSingleComponentFactory
     399             : 
     400           5 : Reference< XInterface > OFactoryComponentHelper::createInstanceWithContext(
     401             :     Reference< XComponentContext > const & xContext )
     402             :     throw (Exception, RuntimeException, std::exception)
     403             : {
     404           5 :     if( bOneInstance )
     405             :     {
     406           0 :         if( !xTheInstance.is() )
     407             :         {
     408           0 :             MutexGuard aGuard( aMutex );
     409             : //          OSL_ENSURE( !xTheInstance.is(), "### context will be ignored!" );
     410           0 :             if( !xTheInstance.is() )
     411           0 :                 xTheInstance = OSingleFactoryHelper::createInstanceWithContext( xContext );
     412             :         }
     413           0 :         return xTheInstance;
     414             :     }
     415           5 :     return OSingleFactoryHelper::createInstanceWithContext( xContext );
     416             : }
     417             : 
     418           3 : Reference< XInterface > OFactoryComponentHelper::createInstanceWithArgumentsAndContext(
     419             :     Sequence< Any > const & rArguments,
     420             :     Reference< XComponentContext > const & xContext )
     421             :     throw (Exception, RuntimeException, std::exception)
     422             : {
     423           3 :     if( bOneInstance )
     424             :     {
     425           0 :         if( !xTheInstance.is() )
     426             :         {
     427           0 :             MutexGuard aGuard( aMutex );
     428             : //          OSL_ENSURE( !xTheInstance.is(), "### context and arguments will be ignored!" );
     429           0 :             if( !xTheInstance.is() )
     430           0 :                 xTheInstance = OSingleFactoryHelper::createInstanceWithArgumentsAndContext( rArguments, xContext );
     431             :         }
     432           0 :         return xTheInstance;
     433             :     }
     434           3 :     return OSingleFactoryHelper::createInstanceWithArgumentsAndContext( rArguments, xContext );
     435             : }
     436             : 
     437             : 
     438             : // OComponentHelper
     439           5 : void OFactoryComponentHelper::dispose()
     440             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     441             : {
     442           5 :     OComponentHelper::dispose();
     443             : 
     444           5 :     Reference<XInterface > x;
     445             :     {
     446             :         // do not delete in the guard section
     447           5 :         MutexGuard aGuard( aMutex );
     448           5 :         x = xTheInstance;
     449           5 :         xTheInstance.clear();
     450             :     }
     451             :     // if it is a component call dispose at the component
     452          10 :     Reference<XComponent > xComp( x, UNO_QUERY );
     453           5 :     if( xComp.is() )
     454           5 :         xComp->dispose();
     455           5 : }
     456             : 
     457             : // XUnloadingPreference
     458             : // This class is used for single factories, component factories and
     459             : // one-instance factories. Depending on the usage this function has
     460             : // to return different values.
     461             : // one-instance factory: sal_False
     462             : // single factory: sal_True
     463             : // component factory: sal_True
     464           0 : sal_Bool SAL_CALL OFactoryComponentHelper::releaseOnNotification() throw(::com::sun::star::uno::RuntimeException, std::exception)
     465             : {
     466           0 :     if( bOneInstance)
     467           0 :         return sal_False;
     468           0 :     return sal_True;
     469             : }
     470             : 
     471           0 : class ORegistryFactoryHelper : public OFactoryComponentHelper,
     472             :                                public OPropertySetHelper
     473             : 
     474             : {
     475             : public:
     476           0 :     ORegistryFactoryHelper(
     477             :         const Reference<XMultiServiceFactory > & rServiceManager,
     478             :         const OUString & rImplementationName_,
     479             :         const Reference<XRegistryKey > & xImplementationKey_,
     480             :         bool bOneInstance_ = false ) SAL_THROW(())
     481             :             : OFactoryComponentHelper(
     482             :                 rServiceManager, rImplementationName_, 0, 0, 0, bOneInstance_ ),
     483             :               OPropertySetHelper( OComponentHelper::rBHelper ),
     484           0 :               xImplementationKey( xImplementationKey_ )
     485           0 :         {}
     486             : 
     487             :     // XInterface
     488             :     virtual Any SAL_CALL queryInterface( Type const & type )
     489             :         throw (RuntimeException, std::exception) SAL_OVERRIDE;
     490             :     virtual void SAL_CALL acquire() throw () SAL_OVERRIDE;
     491             :     virtual void SAL_CALL release() throw () SAL_OVERRIDE;
     492             :     // XTypeProvider
     493             :     virtual Sequence< Type > SAL_CALL getTypes()
     494             :         throw (RuntimeException, std::exception) SAL_OVERRIDE;
     495             :     // XPropertySet
     496             :     virtual Reference< beans::XPropertySetInfo > SAL_CALL getPropertySetInfo()
     497             :         throw (RuntimeException, std::exception) SAL_OVERRIDE;
     498             : 
     499             :     // OPropertySetHelper
     500             :     virtual IPropertyArrayHelper & SAL_CALL getInfoHelper() SAL_OVERRIDE;
     501             :     virtual sal_Bool SAL_CALL convertFastPropertyValue(
     502             :         Any & rConvertedValue, Any & rOldValue,
     503             :         sal_Int32 nHandle, Any const & rValue )
     504             :         throw (lang::IllegalArgumentException) SAL_OVERRIDE;
     505             :     virtual void SAL_CALL setFastPropertyValue_NoBroadcast(
     506             :         sal_Int32 nHandle, Any const & rValue )
     507             :         throw (Exception, std::exception) SAL_OVERRIDE;
     508             :     using OPropertySetHelper::getFastPropertyValue;
     509             :     virtual void SAL_CALL getFastPropertyValue(
     510             :         Any & rValue, sal_Int32 nHandle ) const SAL_OVERRIDE;
     511             : 
     512             :     // OSingleFactoryHelper
     513             :     Reference<XInterface > createInstanceEveryTime(
     514             :         Reference< XComponentContext > const & xContext )
     515             :         throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException) SAL_OVERRIDE;
     516             : 
     517             :     // XSingleServiceFactory
     518             :     Reference<XInterface > SAL_CALL createInstanceWithArguments(const Sequence<Any>& Arguments)
     519             :         throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     520             :     // XSingleComponentFactory
     521             :     Reference< XInterface > SAL_CALL createInstanceWithArgumentsAndContext(
     522             :         Sequence< Any > const & rArguments,
     523             :         Reference< XComponentContext > const & xContext )
     524             :         throw (Exception, RuntimeException, std::exception) SAL_OVERRIDE;
     525             : 
     526             :     // XServiceInfo
     527             :     Sequence< OUString > SAL_CALL getSupportedServiceNames(void)
     528             :         throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     529             :     // XUnloadingPreference
     530             :     sal_Bool SAL_CALL releaseOnNotification()
     531             :         throw( RuntimeException, std::exception) SAL_OVERRIDE;
     532             : 
     533             : 
     534             : private:
     535             :     Reference< XInterface > createModuleFactory()
     536             :         throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
     537             : 
     538             :     /** The registry key of the implementation section */
     539             :     Reference<XRegistryKey >    xImplementationKey;
     540             :     /** The factory created with the loader. */
     541             :     Reference<XSingleComponentFactory > xModuleFactory;
     542             :     Reference<XSingleServiceFactory >   xModuleFactoryDepr;
     543             :     Reference< beans::XPropertySetInfo > m_xInfo;
     544             :     ::std::auto_ptr< IPropertyArrayHelper > m_property_array_helper;
     545             : protected:
     546             :     using OPropertySetHelper::getTypes;
     547             : };
     548             : 
     549             : // XInterface
     550             : 
     551           0 : Any SAL_CALL ORegistryFactoryHelper::queryInterface(
     552             :     Type const & type ) throw (RuntimeException, std::exception)
     553             : {
     554           0 :     Any ret( OFactoryComponentHelper::queryInterface( type ) );
     555           0 :     if (ret.hasValue())
     556           0 :         return ret;
     557             :     else
     558           0 :         return OPropertySetHelper::queryInterface( type );
     559             : }
     560             : 
     561             : 
     562           0 : void ORegistryFactoryHelper::acquire() throw ()
     563             : {
     564           0 :     OFactoryComponentHelper::acquire();
     565           0 : }
     566             : 
     567             : 
     568           0 : void ORegistryFactoryHelper::release() throw ()
     569             : {
     570           0 :     OFactoryComponentHelper::release();
     571           0 : }
     572             : 
     573             : // XTypeProvider
     574             : 
     575           0 : Sequence< Type > ORegistryFactoryHelper::getTypes() throw (RuntimeException, std::exception)
     576             : {
     577           0 :     Sequence< Type > types( OFactoryComponentHelper::getTypes() );
     578           0 :     sal_Int32 pos = types.getLength();
     579           0 :     types.realloc( pos + 3 );
     580           0 :     Type * p = types.getArray();
     581           0 :     p[ pos++ ] = ::getCppuType(
     582           0 :         reinterpret_cast< Reference< beans::XMultiPropertySet > const * >(0) );
     583           0 :     p[ pos++ ] = ::getCppuType(
     584           0 :         reinterpret_cast< Reference< beans::XFastPropertySet > const * >(0) );
     585           0 :     p[ pos++ ] = ::getCppuType(
     586           0 :         reinterpret_cast< Reference< beans::XPropertySet > const * >(0) );
     587           0 :     return types;
     588             : }
     589             : 
     590             : // XPropertySet
     591             : 
     592             : Reference< beans::XPropertySetInfo >
     593           0 : ORegistryFactoryHelper::getPropertySetInfo() throw (RuntimeException, std::exception)
     594             : {
     595           0 :     ::osl::MutexGuard guard( aMutex );
     596           0 :     if (! m_xInfo.is())
     597           0 :         m_xInfo = createPropertySetInfo( getInfoHelper() );
     598           0 :     return m_xInfo;
     599             : }
     600             : 
     601             : // OPropertySetHelper
     602             : 
     603           0 : IPropertyArrayHelper & ORegistryFactoryHelper::getInfoHelper()
     604             : {
     605           0 :     ::osl::MutexGuard guard( aMutex );
     606           0 :     if (m_property_array_helper.get() == 0)
     607             :     {
     608             :         beans::Property prop(
     609             :             "ImplementationKey" /* name */,
     610             :             0 /* handle */,
     611           0 :             ::getCppuType( &xImplementationKey ),
     612             :             beans::PropertyAttribute::READONLY |
     613           0 :             beans::PropertyAttribute::OPTIONAL );
     614             :         m_property_array_helper.reset(
     615           0 :             new ::cppu::OPropertyArrayHelper( &prop, 1 ) );
     616             :     }
     617           0 :     return *m_property_array_helper.get();
     618             : }
     619             : 
     620             : 
     621           0 : sal_Bool ORegistryFactoryHelper::convertFastPropertyValue(
     622             :     Any &, Any &, sal_Int32, Any const & )
     623             :     throw (lang::IllegalArgumentException)
     624             : {
     625             :     OSL_FAIL( "unexpected!" );
     626           0 :     return false;
     627             : }
     628             : 
     629             : 
     630           0 : void ORegistryFactoryHelper::setFastPropertyValue_NoBroadcast(
     631             :     sal_Int32, Any const & )
     632             :     throw (Exception, std::exception)
     633             : {
     634             :     throw beans::PropertyVetoException(
     635             :         "unexpected: only readonly properties!",
     636           0 :         static_cast< OWeakObject * >(this) );
     637             : }
     638             : 
     639             : 
     640           0 : void ORegistryFactoryHelper::getFastPropertyValue(
     641             :     Any & rValue, sal_Int32 nHandle ) const
     642             : {
     643           0 :     if (nHandle == 0)
     644             :     {
     645           0 :         rValue <<= xImplementationKey;
     646             :     }
     647             :     else
     648             :     {
     649           0 :         rValue.clear();
     650             :         throw beans::UnknownPropertyException(
     651             :             "unknown property!", static_cast< OWeakObject * >(
     652           0 :                 const_cast< ORegistryFactoryHelper * >(this) ) );
     653             :     }
     654           0 : }
     655             : 
     656           0 : Reference<XInterface > ORegistryFactoryHelper::createInstanceEveryTime(
     657             :     Reference< XComponentContext > const & xContext )
     658             :     throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException)
     659             : {
     660           0 :     if( !xModuleFactory.is() && !xModuleFactoryDepr.is() )
     661             :     {
     662           0 :         Reference< XInterface > x( createModuleFactory() );
     663           0 :         if (x.is())
     664             :         {
     665           0 :             MutexGuard aGuard( aMutex );
     666           0 :             if( !xModuleFactory.is() && !xModuleFactoryDepr.is() )
     667             :             {
     668           0 :                 xModuleFactory.set( x, UNO_QUERY );
     669           0 :                 xModuleFactoryDepr.set( x, UNO_QUERY );
     670           0 :             }
     671           0 :         }
     672             :     }
     673           0 :     if( xModuleFactory.is() )
     674             :     {
     675           0 :         return xModuleFactory->createInstanceWithContext( xContext );
     676             :     }
     677           0 :     else if( xModuleFactoryDepr.is() )
     678             :     {
     679           0 :         return xModuleFactoryDepr->createInstance();
     680             :     }
     681             : 
     682           0 :     return Reference<XInterface >();
     683             : }
     684             : 
     685           0 : Reference<XInterface > SAL_CALL ORegistryFactoryHelper::createInstanceWithArguments(
     686             :     const Sequence<Any>& Arguments )
     687             :     throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException, std::exception)
     688             : {
     689           0 :     if( !xModuleFactory.is() && !xModuleFactoryDepr.is() )
     690             :     {
     691           0 :         Reference< XInterface > x( createModuleFactory() );
     692           0 :         if (x.is())
     693             :         {
     694           0 :             MutexGuard aGuard( aMutex );
     695           0 :             if( !xModuleFactory.is() && !xModuleFactoryDepr.is() )
     696             :             {
     697           0 :                 xModuleFactory.set( x, UNO_QUERY );
     698           0 :                 xModuleFactoryDepr.set( x, UNO_QUERY );
     699           0 :             }
     700           0 :         }
     701             :     }
     702           0 :     if( xModuleFactoryDepr.is() )
     703             :     {
     704           0 :         return xModuleFactoryDepr->createInstanceWithArguments( Arguments );
     705             :     }
     706           0 :     else if( xModuleFactory.is() )
     707             :     {
     708             : #if OSL_DEBUG_LEVEL > 1
     709             :         OSL_TRACE( "### no context ORegistryFactoryHelper::createInstanceWithArgumentsAndContext()!" );
     710             : #endif
     711           0 :         return xModuleFactory->createInstanceWithArgumentsAndContext( Arguments, Reference< XComponentContext >() );
     712             :     }
     713             : 
     714           0 :     return Reference<XInterface >();
     715             : }
     716             : 
     717           0 : Reference< XInterface > ORegistryFactoryHelper::createInstanceWithArgumentsAndContext(
     718             :     Sequence< Any > const & rArguments,
     719             :     Reference< XComponentContext > const & xContext )
     720             :     throw (Exception, RuntimeException, std::exception)
     721             : {
     722           0 :     if( !xModuleFactory.is() && !xModuleFactoryDepr.is() )
     723             :     {
     724           0 :         Reference< XInterface > x( createModuleFactory() );
     725           0 :         if (x.is())
     726             :         {
     727           0 :             MutexGuard aGuard( aMutex );
     728           0 :             if( !xModuleFactory.is() && !xModuleFactoryDepr.is() )
     729             :             {
     730           0 :                 xModuleFactory.set( x, UNO_QUERY );
     731           0 :                 xModuleFactoryDepr.set( x, UNO_QUERY );
     732           0 :             }
     733           0 :         }
     734             :     }
     735           0 :     if( xModuleFactory.is() )
     736             :     {
     737           0 :         return xModuleFactory->createInstanceWithArgumentsAndContext( rArguments, xContext );
     738             :     }
     739           0 :     else if( xModuleFactoryDepr.is() )
     740             :     {
     741             : #if OSL_DEBUG_LEVEL > 1
     742             :         if (xContext.is())
     743             :         {
     744             :             OSL_TRACE( "### ignoring context calling ORegistryFactoryHelper::createInstanceWithArgumentsAndContext()!" );
     745             :         }
     746             : #endif
     747           0 :         return xModuleFactoryDepr->createInstanceWithArguments( rArguments );
     748             :     }
     749             : 
     750           0 :     return Reference<XInterface >();
     751             : }
     752             : 
     753             : 
     754             : // OSingleFactoryHelper
     755           0 : Reference< XInterface > ORegistryFactoryHelper::createModuleFactory()
     756             :     throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException)
     757             : {
     758           0 :     OUString aActivatorUrl;
     759           0 :     OUString aActivatorName;
     760           0 :     OUString aLocation;
     761             : 
     762           0 :     Reference<XRegistryKey > xActivatorKey = xImplementationKey->openKey(
     763           0 :         OUString("/UNO/ACTIVATOR") );
     764           0 :     if( xActivatorKey.is() && xActivatorKey->getValueType() == RegistryValueType_ASCII )
     765             :     {
     766           0 :         aActivatorUrl = xActivatorKey->getAsciiValue();
     767             : 
     768           0 :         OUString tmpActivator(aActivatorUrl.getStr());
     769           0 :         sal_Int32 nIndex = 0;
     770           0 :         aActivatorName = tmpActivator.getToken(0, ':', nIndex );
     771             : 
     772           0 :         Reference<XRegistryKey > xLocationKey = xImplementationKey->openKey(
     773           0 :             OUString("/UNO/LOCATION") );
     774           0 :         if( xLocationKey.is() && xLocationKey->getValueType() == RegistryValueType_ASCII )
     775           0 :             aLocation = xLocationKey->getAsciiValue();
     776             :     }
     777             :     else
     778             :     {
     779             :         // old style"url"
     780             :         // the location of the program code of the implementation
     781           0 :         Reference<XRegistryKey > xLocationKey = xImplementationKey->openKey(
     782           0 :             OUString("/UNO/URL") );
     783             :         // is the key of the right type ?
     784           0 :         if( xLocationKey.is() && xLocationKey->getValueType() == RegistryValueType_ASCII )
     785             :         {
     786             :             // one implementation found -> try to activate
     787           0 :             aLocation = xLocationKey->getAsciiValue();
     788             : 
     789             :             // search protocol delimiter
     790             :             sal_Int32 nPos = aLocation.indexOf(
     791           0 :                 OUString("://") );
     792           0 :             if( nPos != -1 )
     793             :             {
     794           0 :                 aActivatorName = aLocation.copy( 0, nPos );
     795           0 :                 if( aActivatorName.equalsAscii( "java" ) )
     796           0 :                     aActivatorName = "com.sun.star.loader.Java";
     797           0 :                 else if( aActivatorName.equalsAscii( "module" ) )
     798           0 :                     aActivatorName = "com.sun.star.loader.SharedLibrary";
     799           0 :                 aLocation = aLocation.copy( nPos + 3 );
     800             :             }
     801           0 :         }
     802             :     }
     803             : 
     804           0 :     Reference< XInterface > xFactory;
     805           0 :     if( !aActivatorName.isEmpty() )
     806             :     {
     807           0 :         Reference<XInterface > x = xSMgr->createInstance( aActivatorName );
     808           0 :         Reference<XImplementationLoader > xLoader( x, UNO_QUERY );
     809           0 :         Reference<XInterface > xMF;
     810           0 :         if (xLoader.is())
     811             :         {
     812           0 :             xFactory = xLoader->activate( aImplementationName, aActivatorUrl, aLocation, xImplementationKey );
     813           0 :         }
     814             :     }
     815           0 :     return xFactory;
     816             : }
     817             : 
     818             : // XServiceInfo
     819           0 : Sequence< OUString > ORegistryFactoryHelper::getSupportedServiceNames(void)
     820             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     821             : {
     822           0 :     MutexGuard aGuard( aMutex );
     823           0 :     if( aServiceNames.getLength() == 0 )
     824             :     {
     825             :         // not yet loaded
     826             :         try
     827             :         {
     828           0 :             Reference<XRegistryKey > xKey = xImplementationKey->openKey(
     829           0 :                 OUString("UNO/SERVICES") );
     830             : 
     831           0 :             if (xKey.is())
     832             :             {
     833             :                 // length of prefix. +1 for the '/' at the end
     834           0 :                 sal_Int32 nPrefixLen = xKey->getKeyName().getLength() + 1;
     835             : 
     836             :                 // Full qualified names like "IMPLEMENTATIONS/TEST/UNO/SERVICES/com.sun.star..."
     837           0 :                 Sequence<OUString> seqKeys = xKey->getKeyNames();
     838           0 :                 OUString* pKeys = seqKeys.getArray();
     839           0 :                 for( sal_Int32 i = 0; i < seqKeys.getLength(); i++ )
     840           0 :                     pKeys[i] = pKeys[i].copy(nPrefixLen);
     841             : 
     842           0 :                 aServiceNames = seqKeys;
     843           0 :             }
     844             :         }
     845           0 :         catch (InvalidRegistryException &)
     846             :         {
     847             :         }
     848             :     }
     849           0 :     return aServiceNames;
     850             : }
     851             : 
     852           0 : sal_Bool SAL_CALL ORegistryFactoryHelper::releaseOnNotification() throw(::com::sun::star::uno::RuntimeException, std::exception)
     853             : {
     854           0 :     bool retVal= true;
     855           0 :     if( isOneInstance() && isInstance())
     856             :     {
     857           0 :         retVal= false;
     858             :     }
     859           0 :     else if( ! isOneInstance())
     860             :     {
     861             :         // try to delegate
     862           0 :         if( xModuleFactory.is())
     863             :         {
     864           0 :             Reference<XUnloadingPreference> xunloading( xModuleFactory, UNO_QUERY);
     865           0 :             if( xunloading.is())
     866           0 :                 retVal= xunloading->releaseOnNotification();
     867             :         }
     868           0 :         else if( xModuleFactoryDepr.is())
     869             :         {
     870           0 :             Reference<XUnloadingPreference> xunloading( xModuleFactoryDepr, UNO_QUERY);
     871           0 :             if( xunloading.is())
     872           0 :                 retVal= xunloading->releaseOnNotification();
     873             :         }
     874             :     }
     875           0 :     return retVal;
     876             : }
     877             : 
     878           0 : class OFactoryProxyHelper : public WeakImplHelper3< XServiceInfo, XSingleServiceFactory,
     879             :                                                     XUnloadingPreference >
     880             : {
     881             :     Reference<XSingleServiceFactory >   xFactory;
     882             : 
     883             : public:
     884             : 
     885           0 :     OFactoryProxyHelper( const Reference<XSingleServiceFactory > & rFactory )
     886             :         SAL_THROW(())
     887           0 :         : xFactory( rFactory )
     888           0 :         {}
     889             : 
     890             :     // XSingleServiceFactory
     891             :     Reference<XInterface > SAL_CALL createInstance()
     892             :         throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     893             :     Reference<XInterface > SAL_CALL createInstanceWithArguments(const Sequence<Any>& Arguments)
     894             :         throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     895             : 
     896             :     // XServiceInfo
     897             :     OUString SAL_CALL getImplementationName()
     898             :         throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     899             :     sal_Bool SAL_CALL supportsService(const OUString& ServiceName)
     900             :         throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     901             :     Sequence< OUString > SAL_CALL getSupportedServiceNames(void)
     902             :         throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     903             :     //XUnloadingPreference
     904             :     sal_Bool SAL_CALL releaseOnNotification()
     905             :         throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     906             : 
     907             : };
     908             : 
     909             : // XSingleServiceFactory
     910           0 : Reference<XInterface > OFactoryProxyHelper::createInstance()
     911             :     throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException, std::exception)
     912             : {
     913           0 :     return xFactory->createInstance();
     914             : }
     915             : 
     916             : // XSingleServiceFactory
     917           0 : Reference<XInterface > OFactoryProxyHelper::createInstanceWithArguments
     918             : (
     919             :     const Sequence<Any>& Arguments
     920             : )
     921             :     throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException, std::exception)
     922             : {
     923           0 :     return xFactory->createInstanceWithArguments( Arguments );
     924             : }
     925             : 
     926             : // XServiceInfo
     927           0 : OUString OFactoryProxyHelper::getImplementationName()
     928             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     929             : {
     930           0 :     Reference<XServiceInfo > xInfo( xFactory, UNO_QUERY  );
     931           0 :     if( xInfo.is() )
     932           0 :         return xInfo->getImplementationName();
     933           0 :     return OUString();
     934             : }
     935             : 
     936             : // XServiceInfo
     937           0 : sal_Bool OFactoryProxyHelper::supportsService(const OUString& ServiceName)
     938             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     939             : {
     940           0 :     return cppu::supportsService(this, ServiceName);
     941             : }
     942             : 
     943             : // XServiceInfo
     944           0 : Sequence< OUString > OFactoryProxyHelper::getSupportedServiceNames(void)
     945             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     946             : {
     947           0 :     Reference<XServiceInfo > xInfo( xFactory, UNO_QUERY  );
     948           0 :     if( xInfo.is() )
     949           0 :         return xInfo->getSupportedServiceNames();
     950           0 :     return Sequence< OUString >();
     951             : }
     952             : 
     953           0 : sal_Bool SAL_CALL OFactoryProxyHelper::releaseOnNotification() throw(::com::sun::star::uno::RuntimeException, std::exception)
     954             : {
     955             : 
     956           0 :     Reference<XUnloadingPreference> pref( xFactory, UNO_QUERY);
     957           0 :     if( pref.is())
     958           0 :         return pref->releaseOnNotification();
     959           0 :     return sal_True;
     960             : }
     961             : 
     962             : // global function
     963           0 : Reference<XSingleServiceFactory > SAL_CALL createSingleFactory(
     964             :     const Reference<XMultiServiceFactory > & rServiceManager,
     965             :     const OUString & rImplementationName,
     966             :     ComponentInstantiation pCreateFunction,
     967             :     const Sequence< OUString > & rServiceNames,
     968             :     rtl_ModuleCount * )
     969             :     SAL_THROW(())
     970             : {
     971             :     return new OFactoryComponentHelper(
     972           0 :         rServiceManager, rImplementationName, pCreateFunction, 0, &rServiceNames, false );
     973             : }
     974             : 
     975             : // global function
     976           0 : Reference<XSingleServiceFactory > SAL_CALL createFactoryProxy(
     977             :     SAL_UNUSED_PARAMETER const Reference<XMultiServiceFactory > &,
     978             :     const Reference<XSingleServiceFactory > & rFactory )
     979             :     SAL_THROW(())
     980             : {
     981           0 :     return new OFactoryProxyHelper( rFactory );
     982             : }
     983             : 
     984             : // global function
     985           0 : Reference<XSingleServiceFactory > SAL_CALL createOneInstanceFactory(
     986             :     const Reference<XMultiServiceFactory > & rServiceManager,
     987             :     const OUString & rImplementationName,
     988             :     ComponentInstantiation pCreateFunction,
     989             :     const Sequence< OUString > & rServiceNames,
     990             :     rtl_ModuleCount * )
     991             :     SAL_THROW(())
     992             : {
     993             :     return new OFactoryComponentHelper(
     994           0 :         rServiceManager, rImplementationName, pCreateFunction, 0, &rServiceNames, true );
     995             : }
     996             : 
     997             : // global function
     998           0 : Reference<XSingleServiceFactory > SAL_CALL createSingleRegistryFactory(
     999             :     const Reference<XMultiServiceFactory > & rServiceManager,
    1000             :     const OUString & rImplementationName,
    1001             :     const Reference<XRegistryKey > & rImplementationKey )
    1002             :     SAL_THROW(())
    1003             : {
    1004             :     return new ORegistryFactoryHelper(
    1005           0 :         rServiceManager, rImplementationName, rImplementationKey, false );
    1006             : }
    1007             : 
    1008             : // global function
    1009           0 : Reference<XSingleServiceFactory > SAL_CALL createOneInstanceRegistryFactory(
    1010             :     const Reference<XMultiServiceFactory > & rServiceManager,
    1011             :     const OUString & rImplementationName,
    1012             :     const Reference<XRegistryKey > & rImplementationKey )
    1013             :     SAL_THROW(())
    1014             : {
    1015             :     return new ORegistryFactoryHelper(
    1016           0 :         rServiceManager, rImplementationName, rImplementationKey, true );
    1017             : }
    1018             : 
    1019             : 
    1020           5 : Reference< lang::XSingleComponentFactory > SAL_CALL createSingleComponentFactory(
    1021             :     ComponentFactoryFunc fptr,
    1022             :     OUString const & rImplementationName,
    1023             :     Sequence< OUString > const & rServiceNames,
    1024             :     rtl_ModuleCount *)
    1025             :     SAL_THROW(())
    1026             : {
    1027             :     return new OFactoryComponentHelper(
    1028           5 :         Reference< XMultiServiceFactory >(), rImplementationName, 0, fptr, &rServiceNames, false );
    1029             : }
    1030             : 
    1031           0 : Reference< lang::XSingleComponentFactory > SAL_CALL createOneInstanceComponentFactory(
    1032             :     ComponentFactoryFunc fptr,
    1033             :     OUString const & rImplementationName,
    1034             :     Sequence< OUString > const & rServiceNames,
    1035             :     rtl_ModuleCount *)
    1036             :     SAL_THROW(())
    1037             : {
    1038             :     return new OFactoryComponentHelper(
    1039           0 :         Reference< XMultiServiceFactory >(), rImplementationName, 0, fptr, &rServiceNames, true );
    1040             : }
    1041             : 
    1042             : }
    1043             : 
    1044             : 
    1045             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10