cppuhelper/source/factory.cxx

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