cppuhelper/source/factory.cxx

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