configmgr/source/api2/provider.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: provider.cxx,v $
  10  * $Revision: 1.19 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_configmgr.hxx"
  33
  34 #include "apiserviceinfo.hxx"
  35 #include "confapifactory.hxx"
  36 #include "configpath.hxx"
  37 #include "datalock.hxx"
  38 #include "provider.hxx"
  39 #include "providerimpl.hxx"
  40 #include "tracer.hxx"
  41 #include "bootstrap.hxx"
  42 #include "wrapexception.hxx"
  43 #include <osl/mutex.hxx>
  44 #include <rtl/ustrbuf.hxx>
  45 #ifndef __SGI_STL_ALGORITHM
  46 #include <algorithm>
  47 #endif
  48 #include <comphelper/sequence.hxx>
  49 #include <cppuhelper/typeprovider.hxx>
  50 #include <com/sun/star/beans/PropertyValue.hpp>
  51 #include <cppuhelper/typeprovider.hxx>
  52 #include <com/sun/star/lang/ServiceNotRegisteredException.hpp>
  53 #include <com/sun/star/lang/XEventListener.hpp>
  54
  55 namespace configmgr
  56 {
  57     namespace css  = ::com::sun::star;
  58     namespace uno  = css::uno;
  59     namespace lang = css::lang;
  60     namespace beans = css::beans;
  61
  62     namespace
  63     {
  64     //------------------------------------------------------------------------
  65         sal_Char const * const aConfigProviderServices[] =
  66         {
  67             "com.sun.star.configuration.ConfigurationProvider",
  68             0
  69         };
  70         sal_Char const * const aAdminProviderServices[] =
  71         {
  72             "com.sun.star.configuration.AdministrationProvider",
  73             0
  74         };
  75     //------------------------------------------------------------------------
  76
  77         ServiceImplementationInfo const aConfigProviderInfo =
  78         {
  79             "com.sun.star.comp.configuration.ConfigurationProvider",
  80             aConfigProviderServices,
  81             0
  82         };
  83         ServiceImplementationInfo const aAdminProviderInfo =
  84         {
  85             "com.sun.star.comp.configuration.AdministrationProvider",
  86             aAdminProviderServices,
  87             aConfigProviderServices
  88         };
  89     //------------------------------------------------------------------------
  90
  91         sal_Char const * const
  92             aDefaultProviderServiceAndImplName  = A_DefaultProviderServiceAndImplName;
  93
  94     //------------------------------------------------------------------------
  95
  96         sal_Char const * const aDefaultProviderServices[] =
  97         {
  98             aDefaultProviderServiceAndImplName,
  99             0
 100         };
 101     //------------------------------------------------------------------------
 102
 103         ServiceRegistrationInfo const aDefaultProviderInfo =
 104         {
 105             aDefaultProviderServiceAndImplName,
 106             aDefaultProviderServices
 107         };
 108         SingletonRegistrationInfo const aDefaultProviderSingletonInfo =
 109         {
 110             A_DefaultProviderSingletonName,
 111             aDefaultProviderServiceAndImplName,
 112             aDefaultProviderServiceAndImplName,
 113             0
 114         };
 115     //------------------------------------------------------------------------
 116         typedef uno::Reference< uno::XInterface > (OProviderImpl::*CreatorFunc)(const uno::Sequence< uno::Any >& aArguments);
 117         struct ServiceCreationInfo
 118         {
 119             ServiceRegistrationInfo const* info;
 120             CreatorFunc create;
 121         };
 122
 123         static sal_Int32 getCreateServiceDataCount()
 124         {
 125             return 2;
 126         }
 127
 128         static const ServiceCreationInfo* getCreateServiceData()
 129         {
 130             static ServiceCreationInfo const createServiceData[] =
 131             {
 132                 { &configapi::aCreateReadAccessSI, &OProviderImpl::createReadAccess },
 133                 { &configapi::aCreateUpdateAccessSI, &OProviderImpl::createUpdateAccess },
 134             };
 135             OSL_ENSURE(sizeof(createServiceData)/sizeof(createServiceData[0]) == getCreateServiceDataCount(),
 136                 "getCreateServiceData : inconsistent data !");
 137             return createServiceData;
 138         }
 139     //------------------------------------------------------------------------
 140     }
 141
 142     static ServiceCreationInfo const* findCreationInfo( const rtl::OUString& aServiceSpecifier )
 143     {
 144         for (int i= 0; i<getCreateServiceDataCount(); ++i)
 145         {
 146             ServiceCreationInfo const& rCreationInfo = getCreateServiceData()[i];
 147
 148             ServiceRegistrationInfo const* pInfo = rCreationInfo.info;
 149             if (!pInfo)
 150                 continue;
 151
 152             if (sal_Char const * pImplName = pInfo->implementationName)
 153             {
 154                 if (0 == aServiceSpecifier.compareToAscii(pImplName))
 155                     return &rCreationInfo;
 156             }
 157
 158             if (sal_Char const * const* pNames = pInfo->registeredServiceNames)
 159             {
 160                 while(*pNames)
 161                 {
 162                     if (0 == aServiceSpecifier.compareToAscii(*pNames))
 163                         return &rCreationInfo;
 164
 165                     ++pNames;
 166                 }
 167             }
 168         }
 169         // not found
 170         return 0;
 171     }
 172
 173     //#define ID_PREFETCH               1
 174     static const int ID_PREFETCH=1;
 175     static const int ID_ENABLEASYNC=2;
 176
 177     static inline
 178     rtl::OUString getPrefetchPropName() { return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("PrefetchNodes") ); }
 179     static inline
 180     rtl::OUString getEnableAsyncPropName() { return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("EnableAsync") ); }
 181     //=============================================================================
 182     //= OProvider
 183     //=============================================================================
 184     // service info export
 185     const ServiceRegistrationInfo* getConfigurationProviderServiceInfo()
 186     {
 187         return getRegistrationInfo(&aConfigProviderInfo);
 188     }
 189
 190     const ServiceRegistrationInfo* getAdminProviderServiceInfo()
 191     {
 192         return getRegistrationInfo(&aAdminProviderInfo);
 193     }
 194
 195     const ServiceRegistrationInfo* getDefaultProviderServiceInfo()
 196     {
 197         return &aDefaultProviderInfo;
 198     }
 199
 200     const SingletonRegistrationInfo* getDefaultProviderSingletonInfo()
 201     {
 202         return &aDefaultProviderSingletonInfo;
 203     }
 204
 205     //-----------------------------------------------------------------------------
 206     uno::Reference<uno::XInterface> SAL_CALL
 207         getDefaultConfigProviderSingleton( uno::Reference< uno::XComponentContext > const& xContext )
 208     {
 209         OSL_ENSURE( xContext.is(), "ERROR: NULL context has no singletons" );
 210
 211         UnoContextTunnel aTunnel;
 212         aTunnel.passthru( xContext );
 213
 214         uno::Reference<uno::XInterface> xResult;
 215
 216         if (xContext.is())
 217         try
 218         {
 219             rtl::OUString aSingletonName = SINGLETON(A_DefaultProviderSingletonName);
 220             uno::Any aResult = xContext->getValueByName(aSingletonName);
 221             aResult >>= xResult;
 222         }
 223         catch (uno::Exception & )
 224         {
 225             // to do: really use the tunneled failure when that is set properly
 226             if ( aTunnel.recoverFailure(true).hasValue() )
 227             {
 228                 // have a failure, but can't recover it
 229                 // -> try to regenerate
 230                 instantiateDefaultProvider(xContext);
 231
 232                 OSL_ENSURE(false, "Cannot recreate configuration backend instantiation failure - using generic error");
 233             }
 234             // cannot recover any failure
 235             throw;
 236         }
 237
 238         return xResult;
 239     }
 240     // ------------------------------------------------------------------------
 241     // ----------------------------------------------------------------------------
 242     #define TUNNEL_ALL_EXCEPTIONS()     \
 243         WRAP_CONFIGBACKEND_CREATION_EXCEPTIONS1( UnoContextTunnel::tunnelFailure, true)
 244
 245     // ----------------------------------------------------------------------------
 246     // ------------------------------------------------------------------------
 247
 248     uno::Reference< uno::XInterface > SAL_CALL instantiateDefaultProvider( uno::Reference< uno::XComponentContext > const & xTargetContext )
 249     {
 250         uno::Reference< uno::XComponentContext > xContext = UnoContextTunnel::recoverContext(xTargetContext);
 251
 252         ServiceImplementationInfo const * pProviderInfo =
 253             ContextReader::testAdminService(xContext,true) ? &aAdminProviderInfo : &aConfigProviderInfo;
 254
 255         OProvider* pNewProvider = new OProvider(xContext,pProviderInfo);
 256         uno::Reference< lang::XMultiServiceFactory > aRet( pNewProvider );
 257
 258         try
 259         {
 260             pNewProvider->connect();
 261         }
 262         TUNNEL_ALL_EXCEPTIONS()
 263
 264             return  uno::Reference< uno::XInterface >( aRet, uno::UNO_QUERY );
 265     }
 266
 267     // -----------------------------------------------------------------------------
 268     class OProviderDisposingListener : public cppu::WeakImplHelper1<lang::XEventListener>
 269     {
 270         OProvider* m_pProvider;
 271
 272     public:
 273         OProviderDisposingListener(OProvider* pProvider)
 274             :m_pProvider(pProvider){}
 275
 276         virtual void SAL_CALL disposing(com::sun::star::lang::EventObject const& rEvt) throw()
 277             {
 278                 CFG_TRACE_INFO("Service Manager or context disposed, disposing the provider");
 279                 if (OProvider* pProvider = m_pProvider)
 280                 {
 281                     m_pProvider = NULL;
 282                     pProvider->disposing(rEvt);
 283                 }
 284             }
 285     };
 286
 287     //=============================================================================
 288     //= OProvider
 289     //=============================================================================
 290     //-----------------------------------------------------------------------------
 291     OProvider::OProvider(uno::Reference< uno::XComponentContext > const & xContext, ServiceImplementationInfo const* pInfo)
 292               :ServiceComponentImpl(pInfo)
 293               ,OPropertyContainer(ServiceComponentImpl::rBHelper)
 294               ,m_xContext(xContext)
 295               ,m_pImpl(NULL)
 296               ,m_bEnableAsync(false)
 297     {
 298         OSL_ENSURE(m_xContext.is(), "Creating a provider without a context");
 299         attachToContext();
 300         registerProperty(getPrefetchPropName(), ID_PREFETCH, 0,&m_aPrefetchNodes, ::getCppuType(&m_aPrefetchNodes));
 301         registerProperty(getEnableAsyncPropName(),      ID_ENABLEASYNC, 0, &m_bEnableAsync, ::getBooleanCppuType());
 302     }
 303
 304     //-----------------------------------------------------------------------------
 305     OProvider::~OProvider()
 306     {
 307         delete m_pImpl;
 308         discardContext(releaseContext());
 309     }
 310
 311     //-----------------------------------------------------------------------------
 312     void OProvider::connect() throw (uno::Exception)
 313     {
 314         OSL_ENSURE( m_pImpl == NULL, "Error: Configuration Provider already is connected");
 315
 316         std::auto_ptr<OProviderImpl> pNewImpl( new OProviderImpl(this, m_xContext) );
 317
 318         implConnect(*pNewImpl,ContextReader(m_xContext));
 319
 320         m_pImpl = pNewImpl.release();
 321         if (m_pImpl)
 322         {
 323             sal_Bool isEnabled = m_pImpl->getDefaultOptions().isAsyncEnabled();
 324             this->setPropertyValue( getEnableAsyncPropName(), uno::makeAny(isEnabled) );
 325         }
 326     }
 327
 328     //-----------------------------------------------------------------------------
 329     void OProvider::attachToContext()
 330     {
 331         UnoApiLock aLock;
 332         ::osl::MutexGuard aGuard(ServiceComponentImpl::rBHelper.rMutex);
 333         OSL_ASSERT(!m_xDisposeListener.is());
 334         if (m_xContext.is())
 335         {
 336             uno::Reference< lang::XComponent > xContextComp(m_xContext, uno::UNO_QUERY);
 337             uno::Reference< lang::XComponent > xServiceMgrComp(m_xContext->getServiceManager(), uno::UNO_QUERY);
 338
 339             m_xDisposeListener = new OProviderDisposingListener(this);
 340
 341             if (xContextComp.is())    xContextComp   ->addEventListener(m_xDisposeListener);
 342             if (xServiceMgrComp.is()) xServiceMgrComp->addEventListener(m_xDisposeListener);
 343
 344             OSL_ENSURE(xServiceMgrComp.is() || xContextComp.is(),
 345                         "Provider cannot detect shutdown -> no XComponent found");
 346         }
 347     }
 348
 349     //-----------------------------------------------------------------------------
 350     uno::Reference< lang::XComponent > OProvider::releaseContext()
 351     {
 352         UnoApiLock aLock;
 353         ::osl::MutexGuard aGuard(ServiceComponentImpl::rBHelper.rMutex);
 354
 355         uno::Reference< lang::XComponent > xContextComp(m_xContext, uno::UNO_QUERY);
 356         if (m_xDisposeListener.is() && m_xContext.is())
 357         {
 358             uno::Reference< lang::XComponent > xServiceMgrComp(m_xContext->getServiceManager(), uno::UNO_QUERY);
 359
 360             if (xContextComp.is())
 361             {
 362                 try { xContextComp   ->removeEventListener(m_xDisposeListener); }
 363                 catch (uno::Exception & ) {}
 364             }
 365
 366             if (xServiceMgrComp.is())
 367             {
 368                 try { xServiceMgrComp->removeEventListener(m_xDisposeListener); }
 369                 catch (uno::Exception & ) {}
 370             }
 371         }
 372         m_xDisposeListener = NULL;
 373         m_xContext = NULL;
 374
 375         return xContextComp;
 376     }
 377     //-----------------------------------------------------------------------------
 378
 379     void OProvider::discardContext(uno::Reference< lang::XComponent > const & xContext)
 380     {
 381         UnoApiLock aLock;
 382         if (xContext.is())
 383         {
 384             uno::Reference< uno::XComponentContext > xCC(xContext,uno::UNO_QUERY);
 385             OSL_ASSERT(xCC.is());
 386
 387             if (BootstrapContext::isWrapper(xCC))
 388             {
 389                 try { xContext->dispose(); }
 390                 catch (uno::Exception & ) {}
 391             }
 392         }
 393     }
 394     //-----------------------------------------------------------------------------
 395     // XTypeProvider
 396     //-----------------------------------------------------------------------------
 397     uno::Sequence< uno::Type > SAL_CALL OProvider::getTypes(  ) throw(uno::RuntimeException)
 398     {
 399         cppu::OTypeCollection aCollection(::getCppuType( (const uno::Reference< beans::XPropertySet > *)0 ),
 400                                           ::getCppuType( (const uno::Reference< beans::XFastPropertySet > *)0 ),
 401                                           ::getCppuType( (const uno::Reference< beans::XMultiPropertySet > *)0 ),
 402                                           ::comphelper::concatSequences(ServiceComponentImpl::getTypes(), cppu::ImplHelper4< lang::XMultiServiceFactory, lang::XLocalizable, util::XRefreshable, util::XFlushable >::getTypes()));
 403         return aCollection.getTypes();
 404     }
 405
 406     // XPropertySet
 407     //-----------------------------------------------------------------------------
 408     uno::Reference< ::com::sun::star::beans::XPropertySetInfo > SAL_CALL OProvider::getPropertySetInfo(  ) throw(::com::sun::star::uno::RuntimeException)
 409     {
 410         return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper());
 411     }
 412
 413     //-----------------------------------------------------------------------------
 414     uno::Reference< uno::XInterface > SAL_CALL OProvider::createInstance( const rtl::OUString& aServiceSpecifier )
 415         throw(uno::Exception, uno::RuntimeException)
 416     {
 417         UnoApiLock aLock;
 418         // same as creating with empty sequence of arguments
 419         return this->createInstanceWithArguments( aServiceSpecifier, uno::Sequence< uno::Any >() );
 420     }
 421
 422     //-----------------------------------------------------------------------------
 423     uno::Reference< uno::XInterface > SAL_CALL
 424         OProvider::createInstanceWithArguments( const rtl::OUString& aServiceSpecifier, const uno::Sequence< uno::Any >& aArguments )
 425             throw(uno::Exception, uno::RuntimeException)
 426     {
 427         UnoApiLock aLock;
 428
 429         OSL_ENSURE(m_pImpl, "OProvider: no implementation available");
 430
 431         if (ServiceCreationInfo const* pInfo = findCreationInfo(aServiceSpecifier))
 432         {
 433             // it's a known service name - try to create without args
 434             if (CreatorFunc create = pInfo->create)
 435             {
 436                 return (m_pImpl->*create)(aArguments);
 437             }
 438         }
 439
 440         rtl::OUStringBuffer sMsg;
 441         sMsg.appendAscii("ConfigurationProvider: Cannot create view - ");
 442         sMsg.append( aServiceSpecifier ) .appendAscii(" is not a valid configuration access service. ");
 443
 444         throw lang::ServiceNotRegisteredException(sMsg.makeStringAndClear(),*this);
 445     }
 446
 447     //-----------------------------------------------------------------------------
 448     uno::Sequence< rtl::OUString > SAL_CALL OProvider::getAvailableServiceNames(  )
 449         throw(uno::RuntimeException)
 450     {
 451         UnoApiLock aLock;
 452
 453         sal_Int32 nCount = 0;
 454         {
 455             for (int i= 0; i< getCreateServiceDataCount(); ++i)
 456                 nCount += countServices(getCreateServiceData()[i].info);
 457         }
 458
 459         uno::Sequence< rtl::OUString > aNames(nCount);
 460         if (nCount > 0)
 461         {
 462             sal_Int32 n = 0;
 463             for (int i= 0; i<getCreateServiceDataCount(); ++i)
 464             {
 465                 ServiceRegistrationInfo const* pInfo = getCreateServiceData()[i].info;
 466                 sal_Char const * const* pNames = pInfo ? pInfo->registeredServiceNames : 0;
 467
 468                 if (pNames)
 469                 {
 470                     while(*pNames)
 471                     {
 472                         aNames[n] = rtl::OUString::createFromAscii(*pNames);
 473                         ++n;
 474                         ++pNames;
 475                     }
 476                 }
 477             }
 478         }
 479
 480         return aNames;
 481     }
 482
 483     // XLocalizable
 484     //-----------------------------------------------------------------------------
 485     void SAL_CALL OProvider::setLocale( const lang::Locale& eLocale )
 486         throw (uno::RuntimeException)
 487     {
 488         UnoApiLock aLock;
 489
 490         OSL_ENSURE(m_pImpl, "OProvider: no implementation available");
 491
 492         m_pImpl->setDefaultLocale( eLocale );
 493     }
 494
 495     //-----------------------------------------------------------------------------
 496     lang::Locale SAL_CALL OProvider::getLocale()
 497         throw (uno::RuntimeException)
 498     {
 499         UnoApiLock aLock;
 500
 501         OSL_ENSURE(m_pImpl, "OProvider: no implementation available");
 502
 503         return m_pImpl->getDefaultOptions().getUnoLocale();
 504     }
 505
 506     //XRefreshable
 507     //-----------------------------------------------------------------------------
 508     void SAL_CALL OProvider::refresh()
 509         throw (uno::RuntimeException)
 510      {
 511         UnoApiLock aLock;
 512
 513         OSL_ENSURE(m_pImpl, "OProvider: no implementation available");
 514
 515         try
 516         {
 517             m_pImpl->refreshAll();
 518         }
 519         catch (uno::RuntimeException& ) { throw; }
 520         catch (uno::Exception& e)
 521         {
 522             // FIXME: use getCaughtException()
 523             throw lang::WrappedTargetRuntimeException(e.Message, *this, uno::makeAny(e));
 524         }
 525         //Broadcast the changes
 526         uno::Reference< css::util::XRefreshListener > const * const pRefresh = 0;
 527         cppu::OInterfaceContainerHelper * aInterfaceContainer=
 528             getBroadcastHelper().getContainer (::getCppuType(pRefresh));
 529
 530         if(aInterfaceContainer)
 531         {
 532             lang::EventObject aEventObject(*this);
 533
 534             cppu::OInterfaceIteratorHelper aIterator(*aInterfaceContainer);
 535             while(aIterator.hasMoreElements())
 536             {
 537                 uno::Reference< uno::XInterface > xIface = aIterator.next();
 538                 uno::Reference< util::XRefreshListener > xRefresh (xIface, uno::UNO_QUERY);
 539                 if (xRefresh.is())
 540                 {
 541                     xRefresh->refreshed(aEventObject);
 542                 }
 543             }
 544         }
 545      }
 546      //-----------------------------------------------------------------------------
 547      void SAL_CALL OProvider::addRefreshListener(
 548          const uno::Reference< util::XRefreshListener >& aListener )
 549             throw (uno::RuntimeException)
 550      {
 551         UnoApiLock aLock;
 552         getBroadcastHelper().addListener(::getCppuType(&aListener), aListener);
 553      }
 554      //-----------------------------------------------------------------------------
 555      void SAL_CALL OProvider::removeRefreshListener(
 556          const uno::Reference< util::XRefreshListener >& aListener )
 557             throw (uno::RuntimeException)
 558      {
 559         UnoApiLock aLock;
 560         getBroadcastHelper().removeListener(::getCppuType(&aListener), aListener);
 561      }
 562      //XFlushable
 563      //-----------------------------------------------------------------------------
 564      void SAL_CALL OProvider::flush(  )
 565                 throw (uno::RuntimeException)
 566      {
 567          UnoApiLock aLock;
 568          OSL_ENSURE(m_pImpl, "OProvider: no implementation available");
 569          m_pImpl->flushAll();
 570
 571          //Broadcast the changes
 572          uno::Reference< css::util::XFlushListener > const * const pFlush = 0;
 573          cppu::OInterfaceContainerHelper * aInterfaceContainer=
 574             getBroadcastHelper().getContainer(::getCppuType(pFlush));
 575
 576          if(aInterfaceContainer)
 577          {
 578              lang::EventObject aEventObject(*this);
 579
 580              cppu::OInterfaceIteratorHelper aIterator(*aInterfaceContainer);
 581              while(aIterator.hasMoreElements())
 582              {
 583                  uno::Reference< uno::XInterface > xIface = aIterator.next();
 584                  uno::Reference< util::XFlushListener > xFlush (xIface, uno::UNO_QUERY);
 585                  if (xFlush.is())
 586                  {
 587                      xFlush->flushed(aEventObject);
 588                  }
 589              }
 590          }
 591      }
 592      //-----------------------------------------------------------------------------
 593      void SAL_CALL OProvider::addFlushListener(
 594          const uno::Reference< util::XFlushListener >& aListener )
 595             throw (uno::RuntimeException)
 596      {
 597           UnoApiLock aLock;
 598           getBroadcastHelper().addListener(::getCppuType(&aListener), aListener);
 599      }
 600      //-----------------------------------------------------------------------------
 601      void SAL_CALL OProvider::removeFlushListener(
 602          const uno::Reference< util::XFlushListener >& aListener )
 603             throw (uno::RuntimeException)
 604      {
 605          UnoApiLock aLock;
 606          getBroadcastHelper().removeListener(::getCppuType(&aListener), aListener);
 607      }
 608
 609     // XInterface
 610     //-----------------------------------------------------------------------------
 611     uno::Any SAL_CALL OProvider::queryInterface(uno::Type const& rType) throw(uno::RuntimeException)
 612     {
 613         UnoApiLock aLock;
 614         uno::Any aRet( ServiceComponentImpl::queryInterface(rType) );
 615         if ( !aRet.hasValue() )
 616             aRet = cppu::ImplHelper4< lang::XMultiServiceFactory, lang::XLocalizable, util::XRefreshable, util::XFlushable >::queryInterface(rType);
 617         if ( !aRet.hasValue() )
 618             aRet = queryPropertyInterface(rType);
 619         return aRet;
 620     }
 621
 622     //-----------------------------------------------------------------------------
 623     void OProvider::implConnect(OProviderImpl& _rFreshProviderImpl, const ContextReader& _rSettings) throw(uno::Exception)
 624     {
 625         UnoApiLock aLock;
 626         if (!_rFreshProviderImpl.initSession(_rSettings))
 627             throw uno::Exception(::rtl::OUString::createFromAscii("Could not connect to the configuration. Please check your settings."), static_cast< ::cppu::OWeakObject* >(this) );
 628     }
 629
 630     //-----------------------------------------------------------------------------
 631        void SAL_CALL OProvider::disposing(com::sun::star::lang::EventObject const& /*rEvt*/) throw()
 632     {
 633         UnoApiLock aLock;
 634         releaseContext();
 635         this->dispose();
 636     }
 637
 638     //-----------------------------------------------------------------------------
 639     void SAL_CALL OProvider::disposing()
 640     {
 641         UnoApiLock aLock;
 642
 643         if (m_pImpl)
 644             m_pImpl->dispose();
 645
 646         uno::Reference< lang::XComponent > xComp = releaseContext();
 647
 648         ServiceComponentImpl::disposing();
 649         OPropertyContainer::disposing();
 650
 651         discardContext( xComp );
 652     }
 653
 654     // OPropertyArrayUsageHelper
 655     // -------------------------------------------------------------------------
 656     ::cppu::IPropertyArrayHelper* OProvider::createArrayHelper( ) const
 657     {
 658         UnoApiLock aLock;
 659         uno::Sequence< beans::Property > aProps;
 660         describeProperties(aProps);
 661         return new ::cppu::OPropertyArrayHelper(aProps);
 662     }
 663     // -------------------------------------------------------------------------
 664     ::cppu::IPropertyArrayHelper & OProvider::getInfoHelper()
 665     {
 666         UnoApiLock aLock;
 667         return *getArrayHelper();
 668     }
 669
 670     void SAL_CALL OProvider::setFastPropertyValue_NoBroadcast(  sal_Int32 nHandle, const ::com::sun::star::uno::Any& rValue)
 671                                                  throw (::com::sun::star::uno::Exception)
 672     {
 673         UnoApiLock aLock;
 674
 675         OPropertyContainer::setFastPropertyValue_NoBroadcast( nHandle, rValue );
 676
 677         switch(nHandle)
 678         {
 679             case ID_PREFETCH:
 680             {
 681                 uno::Sequence< rtl::OUString > aNodeList;
 682                 rValue >>= aNodeList;
 683
 684                 RequestOptions const aOptions = m_pImpl->getDefaultOptions();
 685
 686                 for (sal_Int32 i = 0; i < aNodeList.getLength(); i++)
 687                 {
 688                     configuration::AbsolutePath aModulePath = configuration::AbsolutePath::makeModulePath(aNodeList[i]);
 689                     m_pImpl->fetchSubtree(aModulePath , aOptions);
 690                 }
 691             }break;
 692
 693             case ID_ENABLEASYNC:
 694             {
 695                 //Forward to TreeManager
 696                 sal_Bool bAsync;
 697                 if (rValue >>= bAsync)
 698                 {
 699                     m_pImpl->enableAsync(bAsync);
 700                     if (!bAsync)
 701                         this->flush();
 702                 }
 703                 else
 704                     OSL_ENSURE(false, "Unexpected type of new property value");
 705             }
 706             break;
 707             default:
 708             {
 709                 OSL_ENSURE(false, "OProvider::setFastPropertyValue_NoBroadcast -unknown property");
 710             }
 711
 712         }
 713     }
 714 } // namespace configmgr