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