cppuhelper/source/factory.cxx

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