stoc/source/servicemanager/servicemanager.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/config.h>
  21
  22 #include <o3tl/any.hxx>
  23 #include <osl/mutex.hxx>
  24 #include <osl/diagnose.h>
  25 #include <rtl/ref.hxx>
  26 #include <rtl/ustrbuf.hxx>
  27
  28 #include <uno/mapping.hxx>
  29 #include <uno/dispatcher.h>
  30 #include <cppuhelper/queryinterface.hxx>
  31 #include <cppuhelper/weakref.hxx>
  32 #include <cppuhelper/component.hxx>
  33 #include <cppuhelper/implbase.hxx>
  34 #include <cppuhelper/implementationentry.hxx>
  35 #include <cppuhelper/component_context.hxx>
  36 #include <cppuhelper/bootstrap.hxx>
  37 #include <cppuhelper/compbase.hxx>
  38 #include <cppuhelper/supportsservice.hxx>
  39 #include <comphelper/sequence.hxx>
  40
  41 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  42 #include <com/sun/star/lang/XMultiComponentFactory.hpp>
  43 #include <com/sun/star/lang/XServiceInfo.hpp>
  44 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  45 #include <com/sun/star/lang/XInitialization.hpp>
  46 #include <com/sun/star/lang/XEventListener.hpp>
  47 #include <com/sun/star/lang/DisposedException.hpp>
  48 #include <com/sun/star/beans/XPropertySet.hpp>
  49 #include <com/sun/star/beans/PropertyAttribute.hpp>
  50 #include <com/sun/star/registry/XRegistryKey.hpp>
  51 #include <com/sun/star/registry/XSimpleRegistry.hpp>
  52 #include <com/sun/star/container/XSet.hpp>
  53 #include <com/sun/star/container/XElementAccess.hpp>
  54 #include <com/sun/star/container/XEnumeration.hpp>
  55 #include <com/sun/star/container/XContentEnumerationAccess.hpp>
  56 #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
  57 #include <com/sun/star/uno/XUnloadingPreference.hpp>
  58
  59 #include <unordered_map>
  60 #include <unordered_set>
  61
  62 using namespace com::sun::star;
  63 using namespace css::uno;
  64 using namespace css::beans;
  65 using namespace css::registry;
  66 using namespace css::lang;
  67 using namespace css::container;
  68 using namespace cppu;
  69 using namespace osl;
  70 using namespace std;
  71
  72 namespace {
  73
  74 Sequence< OUString > retrieveAsciiValueList(
  75     const Reference< XSimpleRegistry > &xReg, const OUString &keyName )
  76 {
  77     Reference< XEnumerationAccess > xAccess( xReg, UNO_QUERY );
  78     Sequence< OUString > seq;
  79     if( xAccess.is() )
  80     {
  81         Reference< XEnumeration > xEnum = xAccess->createEnumeration();
  82         while( xEnum.is() && xEnum->hasMoreElements() )
  83         {
  84             Reference< XSimpleRegistry > xTempReg;
  85             xEnum->nextElement() >>= xTempReg;
  86             if( xTempReg.is() )
  87             {
  88                 Sequence< OUString > seq2 = retrieveAsciiValueList( xTempReg, keyName );
  89
  90                 if( seq2.getLength() )
  91                 {
  92                     sal_Int32 n1Len = seq.getLength();
  93                     sal_Int32 n2Len = seq2.getLength();
  94
  95                     seq.realloc( n1Len + n2Len );
  96                     const OUString *pSource = seq2.getConstArray();
  97                     OUString *pTarget = seq.getArray();
  98                     for( int i = 0 ; i < n2Len ; i ++ )
  99                     {
 100                         pTarget[i+n1Len] = pSource[i];
 101                     }
 102                 }
 103             }
 104         }
 105     }
 106     else if( xReg.is () )
 107     {
 108         try
 109         {
 110             Reference< XRegistryKey > rRootKey = xReg->getRootKey();
 111             if( rRootKey.is() )
 112             {
 113                 Reference<XRegistryKey > xKey = rRootKey->openKey(keyName);
 114                 if( xKey.is() )
 115                 {
 116                     seq = xKey->getAsciiListValue();
 117                 }
 118             }
 119         }
 120         catch( InvalidRegistryException & )
 121         {
 122         }
 123         catch (InvalidValueException &)
 124         {
 125         }
 126     }
 127     return seq;
 128 }
 129
 130 /*****************************************************************************
 131     Enumeration by ServiceName
 132 *****************************************************************************/
 133 struct hashRef_Impl
 134 {
 135     size_t operator()(const Reference<XInterface > & rName) const
 136     {
 137         // query to XInterface. The cast to XInterface* must be the same for the same object
 138         Reference<XInterface > x( Reference<XInterface >::query( rName ) );
 139         return reinterpret_cast<size_t>(x.get());
 140     }
 141 };
 142
 143 struct equaltoRef_Impl
 144 {
 145     bool operator()(const Reference<XInterface > & rName1, const Reference<XInterface > & rName2 ) const
 146         { return rName1 == rName2; }
 147 };
 148
 149 typedef std::unordered_set
 150 <
 151     Reference<XInterface >,
 152     hashRef_Impl,
 153     equaltoRef_Impl
 154 > HashSet_Ref;
 155
 156
 157 class ServiceEnumeration_Impl : public WeakImplHelper< XEnumeration >
 158 {
 159 public:
 160     explicit ServiceEnumeration_Impl( const Sequence< Reference<XInterface > > & rFactories )
 161         : aFactories( rFactories )
 162         , nIt( 0 )
 163         {}
 164
 165     // XEnumeration
 166     sal_Bool SAL_CALL hasMoreElements() override;
 167     Any SAL_CALL nextElement() override;
 168 private:
 169     Mutex                               aMutex;
 170     Sequence< Reference<XInterface > >  aFactories;
 171     sal_Int32                           nIt;
 172 };
 173
 174 // XEnumeration
 175 sal_Bool ServiceEnumeration_Impl::hasMoreElements()
 176 {
 177     MutexGuard aGuard( aMutex );
 178     return nIt != aFactories.getLength();
 179 }
 180
 181 // XEnumeration
 182 Any ServiceEnumeration_Impl::nextElement()
 183 {
 184     MutexGuard aGuard( aMutex );
 185     if( nIt == aFactories.getLength() )
 186         throw NoSuchElementException("no more elements");
 187
 188     return Any( &aFactories.getConstArray()[nIt++], cppu::UnoType<XInterface>::get());
 189 }
 190
 191
 192 class PropertySetInfo_Impl : public WeakImplHelper< beans::XPropertySetInfo >
 193 {
 194     Sequence< beans::Property > m_properties;
 195
 196 public:
 197     explicit PropertySetInfo_Impl( Sequence< beans::Property > const & properties )
 198         : m_properties( properties )
 199         {}
 200
 201     // XPropertySetInfo impl
 202     virtual Sequence< beans::Property > SAL_CALL getProperties() override;
 203     virtual beans::Property SAL_CALL getPropertyByName( OUString const & name ) override;
 204     virtual sal_Bool SAL_CALL hasPropertyByName( OUString const & name ) override;
 205 };
 206
 207 Sequence< beans::Property > PropertySetInfo_Impl::getProperties()
 208 {
 209     return m_properties;
 210 }
 211
 212 beans::Property PropertySetInfo_Impl::getPropertyByName( OUString const & name )
 213 {
 214     beans::Property const * p = m_properties.getConstArray();
 215     for ( sal_Int32 nPos = m_properties.getLength(); nPos--; )
 216     {
 217         if (p[ nPos ].Name.equals( name ))
 218             return p[ nPos ];
 219     }
 220     throw beans::UnknownPropertyException(
 221         "unknown property: " + name );
 222 }
 223
 224 sal_Bool PropertySetInfo_Impl::hasPropertyByName( OUString const & name )
 225 {
 226     beans::Property const * p = m_properties.getConstArray();
 227     for ( sal_Int32 nPos = m_properties.getLength(); nPos--; )
 228     {
 229         if (p[ nPos ].Name.equals( name ))
 230             return true;
 231     }
 232     return false;
 233 }
 234
 235
 236 /*****************************************************************************
 237     Enumeration by implementation
 238 *****************************************************************************/
 239 class ImplementationEnumeration_Impl : public WeakImplHelper< XEnumeration >
 240 {
 241 public:
 242     explicit ImplementationEnumeration_Impl( const HashSet_Ref & rImplementationMap )
 243         : aImplementationMap( rImplementationMap )
 244         , aIt( aImplementationMap.begin() )
 245         {}
 246
 247     // XEnumeration
 248     virtual sal_Bool SAL_CALL hasMoreElements() override;
 249     virtual Any SAL_CALL nextElement() override;
 250
 251 private:
 252     Mutex                           aMutex;
 253     HashSet_Ref                     aImplementationMap;
 254     HashSet_Ref::iterator           aIt;
 255 };
 256
 257 // XEnumeration
 258 sal_Bool ImplementationEnumeration_Impl::hasMoreElements()
 259 {
 260     MutexGuard aGuard( aMutex );
 261     return aIt != aImplementationMap.end();
 262 }
 263
 264 // XEnumeration
 265 Any ImplementationEnumeration_Impl::nextElement()
 266 {
 267     MutexGuard aGuard( aMutex );
 268     if( aIt == aImplementationMap.end() )
 269         throw NoSuchElementException("no more elements");
 270
 271     Any ret( &(*aIt), cppu::UnoType<XInterface>::get());
 272     ++aIt;
 273     return ret;
 274 }
 275
 276 /*****************************************************************************
 277     Hash tables
 278 *****************************************************************************/
 279 typedef std::unordered_set
 280 <
 281     OUString,
 282     OUStringHash
 283 > HashSet_OWString;
 284
 285 typedef std::unordered_multimap
 286 <
 287     OUString,
 288     Reference<XInterface >,
 289     OUStringHash
 290 > HashMultimap_OWString_Interface;
 291
 292 typedef std::unordered_map
 293 <
 294     OUString,
 295     Reference<XInterface >,
 296     OUStringHash
 297 > HashMap_OWString_Interface;
 298
 299 /*****************************************************************************
 300     class OServiceManager_Listener
 301 *****************************************************************************/
 302 class OServiceManager_Listener : public WeakImplHelper< XEventListener >
 303 {
 304 private:
 305     WeakReference<XSet > xSMgr;
 306
 307 public:
 308     explicit OServiceManager_Listener( const Reference<XSet > & rSMgr )
 309         : xSMgr( rSMgr )
 310         {}
 311
 312     // XEventListener
 313     virtual void SAL_CALL disposing(const EventObject & rEvt ) override;
 314 };
 315
 316 void OServiceManager_Listener::disposing(const EventObject & rEvt )
 317 {
 318     Reference<XSet > x( xSMgr );
 319     if( x.is() )
 320     {
 321         try
 322         {
 323             x->remove( Any( &rEvt.Source, cppu::UnoType<XInterface>::get()) );
 324         }
 325         catch( const IllegalArgumentException & )
 326         {
 327             OSL_FAIL( "IllegalArgumentException caught" );
 328         }
 329         catch( const NoSuchElementException & )
 330         {
 331             OSL_FAIL( "NoSuchElementException caught" );
 332         }
 333     }
 334 }
 335
 336
 337 /*****************************************************************************
 338     class OServiceManager
 339 *****************************************************************************/
 340 struct OServiceManagerMutex
 341 {
 342     Mutex m_mutex;
 343 };
 344
 345 typedef WeakComponentImplHelper<
 346     lang::XMultiServiceFactory, lang::XMultiComponentFactory, lang::XServiceInfo,
 347     lang::XInitialization,
 348     container::XSet, container::XContentEnumerationAccess,
 349     beans::XPropertySet > t_OServiceManager_impl;
 350
 351 class OServiceManager
 352     : public OServiceManagerMutex
 353     , public t_OServiceManager_impl
 354 {
 355 public:
 356     explicit OServiceManager( Reference< XComponentContext > const & xContext );
 357
 358     // XInitialization
 359     void SAL_CALL initialize( Sequence< Any > const & args ) override;
 360
 361     // XServiceInfo
 362     virtual OUString SAL_CALL getImplementationName() override;
 363     virtual sal_Bool SAL_CALL supportsService(const OUString& ServiceName) override;
 364     virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
 365
 366     // XMultiComponentFactory
 367     virtual Reference< XInterface > SAL_CALL createInstanceWithContext(
 368         OUString const & rServiceSpecifier, Reference< XComponentContext > const & xContext ) override;
 369     virtual Reference< XInterface > SAL_CALL createInstanceWithArgumentsAndContext(
 370         OUString const & rServiceSpecifier,
 371         Sequence< Any > const & rArguments,
 372         Reference< XComponentContext > const & xContext ) override;
 373 //      virtual Sequence< OUString > SAL_CALL getAvailableServiceNames()
 374 //          throw (RuntimeException);
 375
 376     // XMultiServiceFactory
 377     virtual Sequence< OUString > SAL_CALL getAvailableServiceNames() override;
 378     virtual Reference<XInterface > SAL_CALL createInstance(const OUString &) override;
 379     virtual Reference<XInterface > SAL_CALL createInstanceWithArguments(const OUString &, const Sequence<Any >& Arguments) override;
 380
 381     // The same as the getAvailableServiceNames, but only unique names
 382     Sequence< OUString > getUniqueAvailableServiceNames(
 383         HashSet_OWString & aNameSet );
 384
 385     // XElementAccess
 386     virtual Type SAL_CALL getElementType() override;
 387     virtual sal_Bool SAL_CALL hasElements() override;
 388
 389     // XEnumerationAccess
 390     virtual Reference<XEnumeration > SAL_CALL createEnumeration() override;
 391
 392     // XSet
 393     virtual sal_Bool SAL_CALL has( const Any & Element ) override;
 394     virtual void SAL_CALL insert( const Any & Element ) override;
 395     virtual void SAL_CALL remove( const Any & Element ) override;
 396
 397     // XContentEnumerationAccess
 398     //Sequence< OUString >          getAvailableServiceNames() throw( (Exception) );
 399     virtual Reference<XEnumeration > SAL_CALL createContentEnumeration(const OUString& aServiceName) override;
 400
 401     // XComponent
 402     virtual void SAL_CALL dispose() override;
 403
 404     // XPropertySet
 405     Reference<XPropertySetInfo > SAL_CALL getPropertySetInfo() override;
 406     void SAL_CALL setPropertyValue(const OUString& PropertyName, const Any& aValue) override;
 407     Any SAL_CALL getPropertyValue(const OUString& PropertyName) override;
 408     void SAL_CALL addPropertyChangeListener(const OUString& PropertyName, const Reference<XPropertyChangeListener >& aListener) override;
 409     void SAL_CALL removePropertyChangeListener(const OUString& PropertyName, const Reference<XPropertyChangeListener >& aListener) override;
 410     void SAL_CALL addVetoableChangeListener(const OUString& PropertyName, const Reference<XVetoableChangeListener >& aListener) override;
 411     void SAL_CALL removeVetoableChangeListener(const OUString& PropertyName, const Reference<XVetoableChangeListener >& aListener) override;
 412
 413 protected:
 414     inline bool is_disposed() const;
 415     inline void check_undisposed() const;
 416     virtual void SAL_CALL disposing() override;
 417
 418     bool haveFactoryWithThisImplementation(const OUString& aImplName);
 419
 420     virtual Sequence< Reference< XInterface > > queryServiceFactories(
 421         const OUString& aServiceName, Reference< XComponentContext > const & xContext );
 422
 423     Reference< XComponentContext >  m_xContext;
 424
 425     Reference< beans::XPropertySetInfo > m_xPropertyInfo;
 426
 427     // factories which have been loaded and not inserted( by XSet::insert)
 428     // are remembered by this set.
 429     HashSet_Ref m_SetLoadedFactories;
 430 private:
 431
 432     Reference<XEventListener >      getFactoryListener();
 433
 434
 435     HashMultimap_OWString_Interface m_ServiceMap;
 436     HashSet_Ref                     m_ImplementationMap;
 437     HashMap_OWString_Interface      m_ImplementationNameMap;
 438     Reference<XEventListener >      xFactoryListener;
 439     bool                            m_bInDisposing;
 440 };
 441
 442
 443 inline bool OServiceManager::is_disposed() const
 444 {
 445     // ought to be guarded by m_mutex:
 446     return (m_bInDisposing || rBHelper.bDisposed);
 447 }
 448
 449
 450 inline void OServiceManager::check_undisposed() const
 451 {
 452     if (is_disposed())
 453     {
 454         throw lang::DisposedException(
 455             "service manager instance has already been disposed!",
 456             static_cast<OWeakObject *>(const_cast<OServiceManager *>(this)) );
 457     }
 458 }
 459
 460
 461 typedef WeakComponentImplHelper<
 462     lang::XMultiServiceFactory, lang::XMultiComponentFactory, lang::XServiceInfo,
 463     container::XSet, container::XContentEnumerationAccess,
 464     beans::XPropertySet > t_OServiceManagerWrapper_impl;
 465
 466 class OServiceManagerWrapper : public OServiceManagerMutex, public t_OServiceManagerWrapper_impl
 467 {
 468     Reference< XComponentContext > m_xContext;
 469     Reference< XMultiComponentFactory > m_root;
 470     Reference< XMultiComponentFactory > const & getRoot()
 471     {
 472         if (! m_root.is())
 473         {
 474             throw lang::DisposedException(
 475                 "service manager instance has already been disposed!" );
 476         }
 477         return m_root;
 478     }
 479
 480 protected:
 481     virtual void SAL_CALL disposing() override;
 482
 483 public:
 484     explicit OServiceManagerWrapper(
 485         Reference< XComponentContext > const & xContext );
 486
 487     // XServiceInfo
 488     virtual OUString SAL_CALL getImplementationName() override
 489         { return Reference< XServiceInfo >(getRoot(), UNO_QUERY_THROW)->getImplementationName(); }
 490     virtual sal_Bool SAL_CALL supportsService(const OUString& ServiceName) override
 491         { return Reference< XServiceInfo >(getRoot(), UNO_QUERY_THROW)->supportsService( ServiceName ); }
 492     virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() override
 493         { return Reference< XServiceInfo >(getRoot(), UNO_QUERY_THROW)->getSupportedServiceNames(); }
 494
 495     // XMultiComponentFactory
 496     virtual Reference< XInterface > SAL_CALL createInstanceWithContext(
 497         OUString const & rServiceSpecifier, Reference< XComponentContext > const & xContext ) override
 498         { return getRoot()->createInstanceWithContext( rServiceSpecifier, xContext ); }
 499     virtual Reference< XInterface > SAL_CALL createInstanceWithArgumentsAndContext(
 500         OUString const & rServiceSpecifier,
 501         Sequence< Any > const & rArguments,
 502         Reference< XComponentContext > const & xContext ) override
 503         { return getRoot()->createInstanceWithArgumentsAndContext( rServiceSpecifier, rArguments, xContext ); }
 504 //      virtual Sequence< OUString > SAL_CALL getAvailableServiceNames()
 505 //          throw (RuntimeException);
 506
 507     // XMultiServiceFactory
 508     virtual Sequence< OUString > SAL_CALL getAvailableServiceNames() override
 509         { return getRoot()->getAvailableServiceNames(); }
 510     virtual Reference<XInterface > SAL_CALL createInstance(const OUString & name) override
 511         { return getRoot()->createInstanceWithContext( name, m_xContext ); }
 512     virtual Reference<XInterface > SAL_CALL createInstanceWithArguments(const OUString & name, const Sequence<Any >& Arguments) override
 513         { return getRoot()->createInstanceWithArgumentsAndContext( name, Arguments, m_xContext ); }
 514
 515     // XElementAccess
 516     virtual Type SAL_CALL getElementType() override
 517         { return Reference< XElementAccess >(getRoot(), UNO_QUERY_THROW)->getElementType(); }
 518     virtual sal_Bool SAL_CALL hasElements() override
 519         { return Reference< XElementAccess >(getRoot(), UNO_QUERY_THROW)->hasElements(); }
 520
 521     // XEnumerationAccess
 522     virtual Reference<XEnumeration > SAL_CALL createEnumeration() override
 523         { return Reference< XEnumerationAccess >(getRoot(), UNO_QUERY_THROW)->createEnumeration(); }
 524
 525     // XSet
 526     virtual sal_Bool SAL_CALL has( const Any & Element ) override
 527         { return Reference< XSet >(getRoot(), UNO_QUERY_THROW)->has( Element ); }
 528     virtual void SAL_CALL insert( const Any & Element ) override
 529         { Reference< XSet >(getRoot(), UNO_QUERY_THROW)->insert( Element ); }
 530     virtual void SAL_CALL remove( const Any & Element ) override
 531         { Reference< XSet >(getRoot(), UNO_QUERY_THROW)->remove( Element ); }
 532
 533     // XContentEnumerationAccess
 534     //Sequence< OUString >          getAvailableServiceNames() throw( (Exception) );
 535     virtual Reference<XEnumeration > SAL_CALL createContentEnumeration(const OUString& aServiceName) override
 536         { return Reference< XContentEnumerationAccess >(getRoot(), UNO_QUERY_THROW)->createContentEnumeration( aServiceName ); }
 537
 538     // XPropertySet
 539     Reference<XPropertySetInfo > SAL_CALL getPropertySetInfo() override
 540         { return Reference< XPropertySet >(getRoot(), UNO_QUERY_THROW)->getPropertySetInfo(); }
 541
 542     void SAL_CALL setPropertyValue(const OUString& PropertyName, const Any& aValue) override;
 543     Any SAL_CALL getPropertyValue(const OUString& PropertyName) override;
 544
 545     void SAL_CALL addPropertyChangeListener(const OUString& PropertyName, const Reference<XPropertyChangeListener >& aListener) override
 546         { Reference< XPropertySet >(getRoot(), UNO_QUERY_THROW)->addPropertyChangeListener( PropertyName, aListener ); }
 547     void SAL_CALL removePropertyChangeListener(const OUString& PropertyName, const Reference<XPropertyChangeListener >& aListener) override
 548         { Reference< XPropertySet >(getRoot(), UNO_QUERY_THROW)->removePropertyChangeListener( PropertyName, aListener ); }
 549     void SAL_CALL addVetoableChangeListener(const OUString& PropertyName, const Reference<XVetoableChangeListener >& aListener) override
 550         { Reference< XPropertySet >(getRoot(), UNO_QUERY_THROW)->addVetoableChangeListener( PropertyName, aListener ); }
 551     void SAL_CALL removeVetoableChangeListener(const OUString& PropertyName, const Reference<XVetoableChangeListener >& aListener) override
 552         { Reference< XPropertySet >(getRoot(), UNO_QUERY_THROW)->removeVetoableChangeListener( PropertyName, aListener ); }
 553 };
 554
 555 void SAL_CALL OServiceManagerWrapper::setPropertyValue(
 556     const OUString& PropertyName, const Any& aValue )
 557 {
 558     if ( PropertyName == "DefaultContext" )
 559     {
 560         Reference< XComponentContext > xContext;
 561         if (aValue >>= xContext)
 562         {
 563             MutexGuard aGuard( m_mutex );
 564             m_xContext = xContext;
 565         }
 566         else
 567         {
 568             throw IllegalArgumentException(
 569                 "no XComponentContext given!",
 570                 static_cast<OWeakObject *>(this), 1 );
 571         }
 572     }
 573     else
 574     {
 575         Reference< XPropertySet >(getRoot(), UNO_QUERY_THROW)->setPropertyValue( PropertyName, aValue );
 576     }
 577 }
 578
 579 Any SAL_CALL OServiceManagerWrapper::getPropertyValue(
 580     const OUString& PropertyName )
 581 {
 582     if ( PropertyName == "DefaultContext" )
 583     {
 584         MutexGuard aGuard( m_mutex );
 585         if( m_xContext.is() )
 586             return makeAny( m_xContext );
 587         else
 588             return Any();
 589     }
 590     else
 591     {
 592         return Reference< XPropertySet >(getRoot(), UNO_QUERY_THROW)->getPropertyValue( PropertyName );
 593     }
 594 }
 595
 596 void OServiceManagerWrapper::disposing()
 597 {
 598     m_xContext.clear();
 599
 600 // no m_root->dispose(), because every context disposes its service manager...
 601     m_root.clear();
 602 }
 603
 604 OServiceManagerWrapper::OServiceManagerWrapper(
 605     Reference< XComponentContext > const & xContext )
 606     : t_OServiceManagerWrapper_impl( m_mutex )
 607     , m_xContext( xContext )
 608     , m_root( xContext->getServiceManager() )
 609 {
 610     if (! m_root.is())
 611     {
 612         throw RuntimeException(
 613             "no service manager to wrap" );
 614     }
 615 }
 616
 617
 618 /**
 619  * Create a ServiceManager
 620  */
 621 OServiceManager::OServiceManager( Reference< XComponentContext > const & xContext )
 622     : t_OServiceManager_impl( m_mutex )
 623     , m_xContext( xContext )
 624     , m_bInDisposing( false )
 625 {}
 626
 627 // XComponent
 628 void OServiceManager::dispose()
 629 {
 630     if (rBHelper.bDisposed || rBHelper.bInDispose)
 631         return;
 632     t_OServiceManager_impl::dispose();
 633 }
 634
 635 void OServiceManager::disposing()
 636 {
 637     // dispose all factories
 638     HashSet_Ref aImpls;
 639     {
 640         MutexGuard aGuard( m_mutex );
 641         m_bInDisposing = true;
 642         aImpls = m_ImplementationMap;
 643     }
 644     HashSet_Ref::iterator aIt = aImpls.begin();
 645     while( aIt != aImpls.end() )
 646     {
 647         try
 648         {
 649             Reference<XComponent > xComp( Reference<XComponent >::query( *aIt++ ) );
 650             if( xComp.is() )
 651                 xComp->dispose();
 652         }
 653         catch (const RuntimeException & exc)
 654         {
 655             SAL_INFO("stoc", "RuntimeException occurred upon disposing factory: " << exc.Message);
 656         }
 657     }
 658
 659     // dispose
 660     HashSet_Ref aImplMap;
 661     {
 662         MutexGuard aGuard( m_mutex );
 663         // erase all members
 664         m_ServiceMap = HashMultimap_OWString_Interface();
 665         aImplMap = m_ImplementationMap;
 666         m_ImplementationMap = HashSet_Ref();
 667         m_ImplementationNameMap = HashMap_OWString_Interface();
 668         m_SetLoadedFactories= HashSet_Ref();
 669     }
 670
 671     m_xContext.clear();
 672
 673     // not only the Event should hold the object
 674     OSL_ASSERT( m_refCount != 1 );
 675 }
 676
 677 // XPropertySet
 678 Reference<XPropertySetInfo > OServiceManager::getPropertySetInfo()
 679 {
 680     check_undisposed();
 681     if (! m_xPropertyInfo.is())
 682     {
 683         Sequence< beans::Property > seq( 1 );
 684         seq[ 0 ] = beans::Property(
 685             "DefaultContext", -1, cppu::UnoType<decltype(m_xContext)>::get(), 0 );
 686         Reference< beans::XPropertySetInfo > xInfo( new PropertySetInfo_Impl( seq ) );
 687
 688         MutexGuard aGuard( m_mutex );
 689         if (! m_xPropertyInfo.is())
 690         {
 691             m_xPropertyInfo = xInfo;
 692         }
 693     }
 694     return m_xPropertyInfo;
 695 }
 696
 697 void OServiceManager::setPropertyValue(
 698     const OUString& PropertyName, const Any& aValue )
 699 {
 700     check_undisposed();
 701     if ( PropertyName == "DefaultContext" )
 702     {
 703         Reference< XComponentContext > xContext;
 704         if (aValue >>= xContext)
 705         {
 706             MutexGuard aGuard( m_mutex );
 707             m_xContext = xContext;
 708         }
 709         else
 710         {
 711             throw IllegalArgumentException(
 712                 "no XComponentContext given!",
 713                 static_cast<OWeakObject *>(this), 1 );
 714         }
 715     }
 716     else
 717     {
 718         throw UnknownPropertyException(
 719             "unknown property " + PropertyName,
 720             static_cast<OWeakObject *>(this) );
 721     }
 722 }
 723
 724 Any OServiceManager::getPropertyValue(const OUString& PropertyName)
 725 {
 726     check_undisposed();
 727     if ( PropertyName == "DefaultContext" )
 728     {
 729         MutexGuard aGuard( m_mutex );
 730         if( m_xContext.is() )
 731             return makeAny( m_xContext );
 732         else
 733             return Any();
 734     }
 735     else
 736     {
 737         UnknownPropertyException except;
 738         except.Message =  "ServiceManager : unknown property " + PropertyName;
 739         throw except;
 740     }
 741 }
 742
 743 void OServiceManager::addPropertyChangeListener(
 744     const OUString&, const Reference<XPropertyChangeListener >&)
 745 {
 746     check_undisposed();
 747     throw UnknownPropertyException("unsupported");
 748 }
 749
 750 void OServiceManager::removePropertyChangeListener(
 751     const OUString&, const Reference<XPropertyChangeListener >&)
 752 {
 753     check_undisposed();
 754     throw UnknownPropertyException("unsupported");
 755 }
 756
 757 void OServiceManager::addVetoableChangeListener(
 758     const OUString&, const Reference<XVetoableChangeListener >&)
 759 {
 760     check_undisposed();
 761     throw UnknownPropertyException("unsupported");
 762 }
 763
 764 void OServiceManager::removeVetoableChangeListener(
 765     const OUString&, const Reference<XVetoableChangeListener >&)
 766 {
 767     check_undisposed();
 768     throw UnknownPropertyException("unsupported");
 769 }
 770
 771 // OServiceManager
 772 Reference<XEventListener > OServiceManager::getFactoryListener()
 773 {
 774     check_undisposed();
 775     MutexGuard aGuard( m_mutex );
 776     if( !xFactoryListener.is() )
 777         xFactoryListener = new OServiceManager_Listener( this );
 778     return xFactoryListener;
 779 }
 780
 781 // XMultiServiceFactory, XContentEnumeration
 782 Sequence< OUString > OServiceManager::getUniqueAvailableServiceNames(
 783     HashSet_OWString & aNameSet )
 784 {
 785     check_undisposed();
 786     MutexGuard aGuard( m_mutex );
 787     HashMultimap_OWString_Interface::iterator aSIt = m_ServiceMap.begin();
 788     while( aSIt != m_ServiceMap.end() )
 789         aNameSet.insert( (*aSIt++).first );
 790
 791     /* do not return the implementation names
 792     HashMap_OWString_Interface      m_ImplementationNameMap;
 793     HashMap_OWString_Interface::iterator aIt = m_ImplementationNameMap.begin();
 794     while( aIt != m_ImplementationNameMap.end() )
 795         aNameSet.insert( (*aIt++).first );
 796     */
 797
 798     return comphelper::containerToSequence(aNameSet);
 799 }
 800
 801 // XMultiComponentFactory
 802 Reference< XInterface > OServiceManager::createInstanceWithContext(
 803     OUString const & rServiceSpecifier,
 804     Reference< XComponentContext > const & xContext )
 805 {
 806     check_undisposed();
 807 #if OSL_DEBUG_LEVEL > 0
 808     Reference< beans::XPropertySet > xProps( xContext->getServiceManager(), UNO_QUERY );
 809     OSL_ASSERT( xProps.is() );
 810     if (xProps.is())
 811     {
 812         Reference< XComponentContext > xDefContext;
 813         xProps->getPropertyValue( "DefaultContext" ) >>= xDefContext;
 814         OSL_ENSURE(
 815             xContext == xDefContext,
 816             "### default context of service manager singleton differs from context holding it!" );
 817     }
 818 #endif
 819
 820     Sequence< Reference< XInterface > > factories(
 821         queryServiceFactories( rServiceSpecifier, xContext ) );
 822     Reference< XInterface > const * p = factories.getConstArray();
 823     for ( sal_Int32 nPos = 0; nPos < factories.getLength(); ++nPos )
 824     {
 825         try
 826         {
 827             Reference< XInterface > const & xFactory = p[ nPos ];
 828             if (xFactory.is())
 829             {
 830                 Reference< XSingleComponentFactory > xFac( xFactory, UNO_QUERY );
 831                 if (xFac.is())
 832                 {
 833                     return xFac->createInstanceWithContext( xContext );
 834                 }
 835                 else
 836                 {
 837                     Reference< XSingleServiceFactory > xFac2( xFactory, UNO_QUERY );
 838                     if (xFac2.is())
 839                     {
 840                         SAL_INFO("stoc", "ignoring given context raising service " << rServiceSpecifier << "!!!");
 841                         return xFac2->createInstance();
 842                     }
 843                 }
 844             }
 845         }
 846         catch (const lang::DisposedException & exc)
 847         {
 848             SAL_INFO("stoc", "DisposedException occurred: " << exc.Message);
 849         }
 850     }
 851
 852     return Reference< XInterface >();
 853 }
 854 // XMultiComponentFactory
 855 Reference< XInterface > OServiceManager::createInstanceWithArgumentsAndContext(
 856     OUString const & rServiceSpecifier,
 857     Sequence< Any > const & rArguments,
 858     Reference< XComponentContext > const & xContext )
 859 {
 860     check_undisposed();
 861 #if OSL_DEBUG_LEVEL > 0
 862     Reference< beans::XPropertySet > xProps( xContext->getServiceManager(), UNO_QUERY );
 863     OSL_ASSERT( xProps.is() );
 864     if (xProps.is())
 865     {
 866         Reference< XComponentContext > xDefContext;
 867         xProps->getPropertyValue( "DefaultContext" ) >>= xDefContext;
 868         OSL_ENSURE(
 869             xContext == xDefContext,
 870             "### default context of service manager singleton differs from context holding it!" );
 871     }
 872 #endif
 873
 874     Sequence< Reference< XInterface > > factories(
 875         queryServiceFactories( rServiceSpecifier, xContext ) );
 876     Reference< XInterface > const * p = factories.getConstArray();
 877     for ( sal_Int32 nPos = 0; nPos < factories.getLength(); ++nPos )
 878     {
 879         try
 880         {
 881             Reference< XInterface > const & xFactory = p[ nPos ];
 882             if (xFactory.is())
 883             {
 884                 Reference< XSingleComponentFactory > xFac( xFactory, UNO_QUERY );
 885                 if (xFac.is())
 886                 {
 887                     return xFac->createInstanceWithArgumentsAndContext( rArguments, xContext );
 888                 }
 889                 else
 890                 {
 891                     Reference< XSingleServiceFactory > xFac2( xFactory, UNO_QUERY );
 892                     if (xFac2.is())
 893                     {
 894                         SAL_INFO("stoc", "ignoring given context raising service " << rServiceSpecifier << "!!!");
 895                         return xFac2->createInstanceWithArguments( rArguments );
 896                     }
 897                 }
 898             }
 899         }
 900         catch (const lang::DisposedException & exc)
 901         {
 902             SAL_INFO("stoc", "DisposedException occurred: " << exc.Message);
 903         }
 904     }
 905
 906     return Reference< XInterface >();
 907 }
 908
 909 // XMultiServiceFactory, XMultiComponentFactory, XContentEnumeration
 910 Sequence< OUString > OServiceManager::getAvailableServiceNames()
 911 {
 912     check_undisposed();
 913     // all names
 914     HashSet_OWString aNameSet;
 915     return getUniqueAvailableServiceNames( aNameSet );
 916 }
 917
 918 // XMultibleServiceFactory
 919 Reference<XInterface > OServiceManager::createInstance(
 920     const OUString& rServiceSpecifier )
 921 {
 922     return createInstanceWithContext(
 923         rServiceSpecifier, m_xContext );
 924 }
 925
 926 // XMultibleServiceFactory
 927 Reference<XInterface > OServiceManager::createInstanceWithArguments(
 928     const OUString& rServiceSpecifier,
 929     const Sequence<Any >& rArguments )
 930 {
 931     return createInstanceWithArgumentsAndContext(
 932         rServiceSpecifier, rArguments, m_xContext );
 933 }
 934
 935 // XInitialization
 936 void OServiceManager::initialize( Sequence< Any > const & )
 937 {
 938     check_undisposed();
 939     OSL_FAIL( "not impl!" );
 940 }
 941
 942 // XServiceInfo
 943 OUString OServiceManager::getImplementationName()
 944 {
 945     return OUString("com.sun.star.comp.stoc.OServiceManager");
 946 }
 947
 948 // XServiceInfo
 949 sal_Bool OServiceManager::supportsService(const OUString& ServiceName)
 950 {
 951     return cppu::supportsService(this, ServiceName);
 952 }
 953
 954 // XServiceInfo
 955 Sequence< OUString > OServiceManager::getSupportedServiceNames()
 956 {
 957     Sequence< OUString > seqNames(2);
 958     seqNames[0] = "com.sun.star.lang.MultiServiceFactory";
 959     seqNames[1] = "com.sun.star.lang.ServiceManager";
 960     return seqNames;
 961 }
 962
 963
 964 Sequence< Reference< XInterface > > OServiceManager::queryServiceFactories(
 965     const OUString& aServiceName, Reference< XComponentContext > const & )
 966 {
 967     Sequence< Reference< XInterface > > ret;
 968
 969     MutexGuard aGuard( m_mutex );
 970     ::std::pair<
 971           HashMultimap_OWString_Interface::iterator,
 972           HashMultimap_OWString_Interface::iterator> p(
 973               m_ServiceMap.equal_range( aServiceName ) );
 974
 975     if (p.first == p.second) // no factories
 976     {
 977         // no service found, look for an implementation
 978         HashMap_OWString_Interface::iterator aIt = m_ImplementationNameMap.find( aServiceName );
 979         if( aIt != m_ImplementationNameMap.end() )
 980         {
 981             Reference< XInterface > const & x = aIt->second;
 982             // an implementation found
 983             ret = Sequence< Reference< XInterface > >( &x, 1 );
 984         }
 985     }
 986     else
 987     {
 988         ::std::vector< Reference< XInterface > > vec;
 989         vec.reserve( 4 );
 990         while (p.first != p.second)
 991         {
 992             vec.push_back( p.first->second );
 993             ++p.first;
 994         }
 995         ret = Sequence< Reference< XInterface > >( vec.data(), vec.size() );
 996     }
 997
 998     return ret;
 999 }
1000
1001 // XContentEnumerationAccess
1002 Reference<XEnumeration > OServiceManager::createContentEnumeration(
1003     const OUString& aServiceName )
1004 {
1005     check_undisposed();
1006     Sequence< Reference< XInterface > > factories(
1007         OServiceManager::queryServiceFactories( aServiceName, m_xContext ) );
1008     if (factories.getLength())
1009         return new ServiceEnumeration_Impl( factories );
1010     else
1011         return Reference< XEnumeration >();
1012 }
1013
1014 // XEnumeration
1015 Reference<XEnumeration > OServiceManager::createEnumeration()
1016 {
1017     check_undisposed();
1018     MutexGuard aGuard( m_mutex );
1019     return new ImplementationEnumeration_Impl( m_ImplementationMap );
1020 }
1021
1022 // XElementAccess
1023 Type OServiceManager::getElementType()
1024 {
1025     check_undisposed();
1026     return cppu::UnoType<XInterface>::get();
1027 }
1028
1029 // XElementAccess
1030 sal_Bool OServiceManager::hasElements()
1031 {
1032     check_undisposed();
1033     MutexGuard aGuard( m_mutex );
1034     return !m_ImplementationMap.empty();
1035 }
1036
1037 // XSet
1038 sal_Bool OServiceManager::has( const Any & Element )
1039 {
1040     check_undisposed();
1041     if( Element.getValueTypeClass() == TypeClass_INTERFACE )
1042     {
1043         Reference<XInterface > xEle( Element, UNO_QUERY_THROW );
1044         MutexGuard aGuard( m_mutex );
1045         return m_ImplementationMap.find( xEle ) !=
1046             m_ImplementationMap.end();
1047     }
1048     else if (auto implName = o3tl::tryAccess<OUString>(Element))
1049     {
1050         MutexGuard aGuard( m_mutex );
1051         return m_ImplementationNameMap.find( *implName ) !=
1052             m_ImplementationNameMap.end();
1053     }
1054     return false;
1055 }
1056
1057 // XSet
1058 void OServiceManager::insert( const Any & Element )
1059 {
1060     check_undisposed();
1061     if( Element.getValueTypeClass() != TypeClass_INTERFACE )
1062     {
1063         throw IllegalArgumentException(
1064             "exception interface, got " + Element.getValueType().getTypeName(),
1065             Reference< XInterface >(), 0 );
1066     }
1067     Reference<XInterface > xEle( Element, UNO_QUERY_THROW );
1068
1069     {
1070     MutexGuard aGuard( m_mutex );
1071     HashSet_Ref::iterator aIt = m_ImplementationMap.find( xEle );
1072     if( aIt != m_ImplementationMap.end() )
1073     {
1074         throw ElementExistException( "element already exists!" );
1075     }
1076
1077     // put into the implementation hashmap
1078     m_ImplementationMap.insert( xEle );
1079
1080     // put into the implementation name hashmap
1081     Reference<XServiceInfo > xInfo( Reference<XServiceInfo >::query( xEle ) );
1082     if( xInfo.is() )
1083     {
1084         OUString aImplName = xInfo->getImplementationName();
1085         if( !aImplName.isEmpty() )
1086             m_ImplementationNameMap[ aImplName ] = xEle;
1087
1088         //put into the service map
1089         Sequence< OUString > aServiceNames = xInfo->getSupportedServiceNames();
1090         const OUString * pArray = aServiceNames.getConstArray();
1091         for( sal_Int32 i = 0; i < aServiceNames.getLength(); i++ )
1092         {
1093             m_ServiceMap.insert( HashMultimap_OWString_Interface::value_type(
1094                 pArray[i], *o3tl::doAccess<Reference<XInterface>>(Element) ) );
1095         }
1096     }
1097     }
1098     // add the disposing listener to the factory
1099     Reference<XComponent > xComp( Reference<XComponent >::query( xEle ) );
1100     if( xComp.is() )
1101         xComp->addEventListener( getFactoryListener() );
1102 }
1103
1104 // helper function
1105 bool OServiceManager::haveFactoryWithThisImplementation(const OUString& aImplName)
1106 {
1107     return ( m_ImplementationNameMap.find(aImplName) != m_ImplementationNameMap.end());
1108 }
1109
1110 // XSet
1111 void OServiceManager::remove( const Any & Element )
1112 {
1113     if (is_disposed())
1114         return;
1115
1116     Reference<XInterface > xEle;
1117     if (Element.getValueTypeClass() == TypeClass_INTERFACE)
1118     {
1119         xEle.set( Element, UNO_QUERY_THROW );
1120     }
1121     else if (auto implName = o3tl::tryAccess<OUString>(Element))
1122     {
1123         MutexGuard aGuard( m_mutex );
1124         HashMap_OWString_Interface::const_iterator const iFind(
1125             m_ImplementationNameMap.find( *implName ) );
1126         if (iFind == m_ImplementationNameMap.end())
1127         {
1128             throw NoSuchElementException(
1129                 "element is not in: " + *implName,
1130                 static_cast< OWeakObject * >(this) );
1131         }
1132         xEle = iFind->second;
1133     }
1134     else
1135     {
1136         throw IllegalArgumentException(
1137             "expected interface or string, got " + Element.getValueType().getTypeName(),
1138             Reference< XInterface >(), 0 );
1139     }
1140
1141     // remove the disposing listener from the factory
1142     Reference<XComponent > xComp( Reference<XComponent >::query( xEle ) );
1143     if( xComp.is() )
1144         xComp->removeEventListener( getFactoryListener() );
1145
1146     MutexGuard aGuard( m_mutex );
1147     HashSet_Ref::iterator aIt = m_ImplementationMap.find( xEle );
1148     if( aIt == m_ImplementationMap.end() )
1149     {
1150         throw NoSuchElementException(
1151             "element not found",
1152             static_cast< OWeakObject * >(this) );
1153     }
1154     //First remove all factories which have been loaded by ORegistryServiceManager.
1155     m_SetLoadedFactories.erase( *aIt);
1156     //Remove from the implementation map. It contains all factories of m_SetLoadedFactories
1157     //which have been added directly through XSet, that is not via ORegistryServiceManager
1158     m_ImplementationMap.erase( aIt );
1159
1160     // remove from the implementation name hashmap
1161     Reference<XServiceInfo > xInfo( Reference<XServiceInfo >::query( xEle ) );
1162     if( xInfo.is() )
1163     {
1164         OUString aImplName = xInfo->getImplementationName();
1165         if( !aImplName.isEmpty() )
1166             m_ImplementationNameMap.erase( aImplName );
1167     }
1168
1169     //remove from the service map
1170     Reference<XServiceInfo > xSF( Reference<XServiceInfo >::query( xEle ) );
1171     if( xSF.is() )
1172     {
1173         Sequence< OUString > aServiceNames = xSF->getSupportedServiceNames();
1174         const OUString * pArray = aServiceNames.getConstArray();
1175         for( sal_Int32 i = 0; i < aServiceNames.getLength(); i++ )
1176         {
1177             pair<HashMultimap_OWString_Interface::iterator, HashMultimap_OWString_Interface::iterator> p =
1178                 m_ServiceMap.equal_range( pArray[i] );
1179
1180             while( p.first != p.second )
1181             {
1182                 if( xEle == (*p.first).second )
1183                 {
1184                     m_ServiceMap.erase( p.first );
1185                     break;
1186                 }
1187                 ++p.first;
1188             }
1189         }
1190     }
1191 }
1192
1193 /*****************************************************************************
1194     class ORegistryServiceManager
1195 *****************************************************************************/
1196 class ORegistryServiceManager : public OServiceManager
1197 {
1198 public:
1199     explicit ORegistryServiceManager( Reference< XComponentContext > const & xContext );
1200
1201     // XInitialization
1202     void SAL_CALL initialize(const Sequence< Any >& Arguments) override;
1203
1204     // XServiceInfo
1205     OUString SAL_CALL getImplementationName() override
1206         { return OUString("com.sun.star.comp.stoc.ORegistryServiceManager"); }
1207
1208     Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
1209
1210     // XMultiServiceFactory
1211     Sequence< OUString > SAL_CALL getAvailableServiceNames() override;
1212
1213     // XContentEnumerationAccess
1214     //Sequence< OUString >          getAvailableServiceNames() throw( (Exception) );
1215     Reference<XEnumeration > SAL_CALL createContentEnumeration(const OUString& aServiceName) override;
1216
1217     // XComponent
1218     void SAL_CALL dispose() override;
1219
1220     // OServiceManager
1221     Reference<XPropertySetInfo > SAL_CALL getPropertySetInfo() override;
1222     Any SAL_CALL getPropertyValue(const OUString& PropertyName) override;
1223
1224 protected:
1225     //OServiceManager
1226     Sequence< Reference< XInterface > > queryServiceFactories(
1227         const OUString& aServiceName, Reference< XComponentContext > const & xContext ) override;
1228 private:
1229     Reference<XRegistryKey >        getRootKey();
1230     Reference<XInterface > loadWithImplementationName(
1231         const OUString & rImplName, Reference< XComponentContext > const & xContext );
1232     Sequence<OUString>          getFromServiceName(const OUString& serviceName);
1233     Reference<XInterface > loadWithServiceName(
1234         const OUString & rImplName, Reference< XComponentContext > const & xContext );
1235     void                        fillAllNamesFromRegistry( HashSet_OWString & );
1236
1237     bool                    m_searchedRegistry;
1238     Reference<XSimpleRegistry > m_xRegistry;    // readonly property Registry
1239     Reference<XRegistryKey >    m_xRootKey;
1240
1241 #if OSL_DEBUG_LEVEL > 0
1242     bool m_init;
1243 #endif
1244 };
1245
1246 /**
1247  * Create a ServiceManager
1248  */
1249 ORegistryServiceManager::ORegistryServiceManager( Reference< XComponentContext > const & xContext )
1250     : OServiceManager( xContext )
1251     , m_searchedRegistry(false)
1252 #if OSL_DEBUG_LEVEL > 0
1253     , m_init( false )
1254 #endif
1255 {
1256 }
1257
1258 // XComponent
1259 void ORegistryServiceManager::dispose()
1260 {
1261     if (rBHelper.bDisposed || rBHelper.bInDispose)
1262         return;
1263     OServiceManager::dispose();
1264     // dispose
1265     MutexGuard aGuard( m_mutex );
1266     // erase all members
1267     m_xRegistry.clear();
1268     m_xRootKey.clear();
1269 }
1270
1271 /**
1272  * Return the root key of the registry. The Default registry service is ordered
1273  * if no registry is set.
1274  */
1275 //Reference<XServiceProvider > create_DefaultRegistry_ServiceProvider();
1276
1277 Reference<XRegistryKey > ORegistryServiceManager::getRootKey()
1278 {
1279     if( !m_xRootKey.is() )
1280     {
1281         MutexGuard aGuard( m_mutex );
1282         //  DefaultRegistry suchen !!!!
1283         if( !m_xRegistry.is() && !m_searchedRegistry )
1284         {
1285             // NB. we only search this once
1286             m_searchedRegistry = true;
1287
1288             m_xRegistry.set(
1289                 createInstanceWithContext(
1290                     "com.sun.star.registry.DefaultRegistry",
1291                     m_xContext ),
1292                 UNO_QUERY );
1293         }
1294         if( m_xRegistry.is() && !m_xRootKey.is() )
1295             m_xRootKey = m_xRegistry->getRootKey();
1296     }
1297
1298     return m_xRootKey;
1299 }
1300
1301 /**
1302  * Create a service provider from the registry with an implementation name
1303  */
1304 Reference<XInterface > ORegistryServiceManager::loadWithImplementationName(
1305     const OUString& name, Reference< XComponentContext > const & xContext )
1306 {
1307     Reference<XInterface > ret;
1308
1309     Reference<XRegistryKey > xRootKey = getRootKey();
1310     if( !xRootKey.is() )
1311         return ret;
1312
1313     try
1314     {
1315         OUString implementationName = "/IMPLEMENTATIONS/" + name;
1316         Reference<XRegistryKey > xImpKey = m_xRootKey->openKey(implementationName);
1317
1318         if( xImpKey.is() )
1319         {
1320             Reference< lang::XMultiServiceFactory > xMgr;
1321             if (xContext.is())
1322                 xMgr.set( xContext->getServiceManager(), UNO_QUERY_THROW );
1323             else
1324                 xMgr.set( this );
1325             ret = createSingleRegistryFactory( xMgr, name, xImpKey );
1326             insert( makeAny( ret ) );
1327             // Remember this factory as loaded in contrast to inserted ( XSet::insert)
1328             // factories. Those loaded factories in this set are candidates for being
1329             // released on an unloading notification.
1330             m_SetLoadedFactories.insert( ret);
1331         }
1332     }
1333     catch (InvalidRegistryException &)
1334     {
1335     }
1336
1337     return ret;
1338 }
1339
1340 /**
1341  * Return all implementation out of the registry.
1342  */
1343 Sequence<OUString> ORegistryServiceManager::getFromServiceName(
1344     const OUString& serviceName )
1345 {
1346     OUStringBuffer buf;
1347     buf.append( "/SERVICES/" );
1348     buf.append( serviceName );
1349     return retrieveAsciiValueList( m_xRegistry, buf.makeStringAndClear() );
1350 }
1351
1352 /**
1353  * Create a service provider from the registry
1354  */
1355 Reference<XInterface > ORegistryServiceManager::loadWithServiceName(
1356     const OUString& serviceName, Reference< XComponentContext > const & xContext )
1357 {
1358     Sequence<OUString> implEntries = getFromServiceName( serviceName );
1359     for (sal_Int32 i = 0; i < implEntries.getLength(); i++)
1360     {
1361         Reference< XInterface > x(
1362             loadWithImplementationName( implEntries.getConstArray()[i], xContext ) );
1363         if (x.is())
1364             return x;
1365     }
1366
1367     return Reference<XInterface >();
1368 }
1369
1370 /**
1371  * Return a sequence of all service names from the registry.
1372  */
1373 void ORegistryServiceManager::fillAllNamesFromRegistry( HashSet_OWString & rSet )
1374 {
1375     Reference<XRegistryKey > xRootKey = getRootKey();
1376     if( !xRootKey.is() )
1377         return;
1378
1379     try
1380     {
1381         Reference<XRegistryKey > xServicesKey = xRootKey->openKey( "SERVICES" );
1382         // root + /Services + /
1383         if( xServicesKey.is() )
1384         {
1385             sal_Int32 nPrefix = xServicesKey->getKeyName().getLength() +1;
1386             Sequence<Reference<XRegistryKey > > aKeys = xServicesKey->openKeys();
1387             for( sal_Int32 i = 0; i < aKeys.getLength(); i++ )
1388                 rSet.insert( aKeys.getConstArray()[i]->getKeyName().copy( nPrefix ) );
1389         }
1390     }
1391     catch (InvalidRegistryException &)
1392     {
1393     }
1394 }
1395
1396 // XInitialization
1397 void ORegistryServiceManager::initialize(const Sequence< Any >& Arguments)
1398 {
1399     check_undisposed();
1400     MutexGuard aGuard( m_mutex );
1401     if (Arguments.getLength() > 0)
1402     {
1403         m_xRootKey.clear();
1404         Arguments[ 0 ] >>= m_xRegistry;
1405     }
1406 #if OSL_DEBUG_LEVEL > 0
1407     // to find all bootstrapping processes to be fixed...
1408     OSL_ENSURE( !m_init, "### second init of service manager instance!" );
1409     m_init = true;
1410 #endif
1411 }
1412
1413 // XMultiServiceFactory, XContentEnumeration
1414 Sequence< OUString > ORegistryServiceManager::getAvailableServiceNames()
1415 {
1416     check_undisposed();
1417     MutexGuard aGuard( m_mutex );
1418     // all names
1419     HashSet_OWString aNameSet;
1420
1421     // all names from the registry
1422     fillAllNamesFromRegistry( aNameSet );
1423
1424     return OServiceManager::getUniqueAvailableServiceNames( aNameSet );
1425 }
1426
1427 // XServiceInfo
1428 Sequence< OUString > ORegistryServiceManager::getSupportedServiceNames()
1429 {
1430     Sequence< OUString > seqNames(2);
1431     seqNames[0] = "com.sun.star.lang.MultiServiceFactory";
1432     seqNames[1] = "com.sun.star.lang.RegistryServiceManager";
1433     return seqNames;
1434 }
1435
1436
1437 // OServiceManager
1438 Sequence< Reference< XInterface > > ORegistryServiceManager::queryServiceFactories(
1439     const OUString& aServiceName, Reference< XComponentContext > const & xContext )
1440 {
1441     Sequence< Reference< XInterface > > ret(
1442         OServiceManager::queryServiceFactories( aServiceName, xContext ) );
1443     if (ret.getLength())
1444     {
1445         return ret;
1446     }
1447     else
1448     {
1449         MutexGuard aGuard( m_mutex );
1450         Reference< XInterface > x( loadWithServiceName( aServiceName, xContext ) );
1451         if (! x.is())
1452             x = loadWithImplementationName( aServiceName, xContext );
1453         return Sequence< Reference< XInterface > >( &x, 1 );
1454     }
1455 }
1456
1457 // XContentEnumerationAccess
1458 Reference<XEnumeration > ORegistryServiceManager::createContentEnumeration(
1459     const OUString& aServiceName )
1460 {
1461     check_undisposed();
1462     MutexGuard aGuard(m_mutex);
1463     // get all implementation names registered under this service name from the registry
1464     Sequence<OUString> aImpls = getFromServiceName( aServiceName );
1465     // load and insert all factories specified by the registry
1466     sal_Int32 i;
1467     OUString aImplName;
1468     for( i = 0; i < aImpls.getLength(); i++ )
1469     {
1470         aImplName = aImpls.getConstArray()[i];
1471         if ( !haveFactoryWithThisImplementation(aImplName) )
1472         {
1473             loadWithImplementationName( aImplName, m_xContext );
1474         }
1475     }
1476     // call the superclass to enumerate all contents
1477     return OServiceManager::createContentEnumeration( aServiceName );
1478 }
1479
1480 // OServiceManager
1481 Reference<XPropertySetInfo > ORegistryServiceManager::getPropertySetInfo()
1482 {
1483     check_undisposed();
1484     if (! m_xPropertyInfo.is())
1485     {
1486         Sequence< beans::Property > seq( 2 );
1487         seq[ 0 ] = beans::Property(
1488             "DefaultContext", -1, cppu::UnoType<decltype(m_xContext)>::get(), 0 );
1489         seq[ 1 ] = beans::Property(
1490             "Registry", -1, cppu::UnoType<decltype(m_xRegistry)>::get(),
1491             beans::PropertyAttribute::READONLY );
1492         Reference< beans::XPropertySetInfo > xInfo( new PropertySetInfo_Impl( seq ) );
1493
1494         MutexGuard aGuard( m_mutex );
1495         if (! m_xPropertyInfo.is())
1496         {
1497             m_xPropertyInfo = xInfo;
1498         }
1499     }
1500     return m_xPropertyInfo;
1501 }
1502
1503 Any ORegistryServiceManager::getPropertyValue(const OUString& PropertyName)
1504 {
1505     check_undisposed();
1506     if ( PropertyName == "Registry" )
1507     {
1508         MutexGuard aGuard( m_mutex );
1509         if( m_xRegistry.is() )
1510             return makeAny( m_xRegistry );
1511         else
1512             return Any();
1513     }
1514     return OServiceManager::getPropertyValue( PropertyName );
1515 }
1516
1517 } // namespace
1518
1519 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * SAL_CALL
1520 com_sun_star_comp_stoc_OServiceManager_get_implementation(
1521     css::uno::XComponentContext *context,
1522     css::uno::Sequence<css::uno::Any> const &)
1523 {
1524     return cppu::acquire(new OServiceManager(context));
1525 }
1526
1527 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * SAL_CALL
1528 com_sun_star_comp_stoc_ORegistryServiceManager_get_implementation(
1529     css::uno::XComponentContext *context,
1530     css::uno::Sequence<css::uno::Any> const &)
1531 {
1532     return cppu::acquire(new ORegistryServiceManager(context));
1533 }
1534
1535 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * SAL_CALL
1536 com_sun_star_comp_stoc_OServiceManagerWrapper_get_implementation(
1537     css::uno::XComponentContext *context,
1538     css::uno::Sequence<css::uno::Any> const &)
1539 {
1540     return cppu::acquire(new OServiceManagerWrapper(context));
1541 }
1542
1543 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */