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

Generated by: LCOV version 1.10