configmgr/source/platformbe/systemintegrationmanager.hxx

   1 #ifndef CONFIGMGR_BACKEND_SYSTEMINTEGRATIONMANAGER_HXX_
   2 #define CONFIGMGR_BACKEND_SYSTEMINTEGRATIONMANAGER_HXX_
   3
   4 #include <com/sun/star/configuration/backend/XBackend.hpp>
   5 #include <com/sun/star/uno/XComponentContext.hpp>
   6 #include <com/sun/star/lang/XInitialization.hpp>
   7 #include <com/sun/star/lang/XServiceInfo.hpp>
   8 #include <com/sun/star/uno/XInterface.hpp>
   9 #include <com/sun/star/configuration/backend/BackendSetupException.hpp>
  10 #include <com/sun/star/configuration/backend/XBackendChangesNotifier.hpp>
  11 #include <com/sun/star/lang/XSingleComponentFactory.hpp>
  12 #include <com/sun/star/configuration/backend/XSingleLayerStratum.hpp>
  13 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  14 #include <cppuhelper/compbase4.hxx>
  15
  16 #ifndef INCLUDED_MAP
  17 #include <map>
  18 #define INCLUDED_MAP
  19 #endif
  20
  21 namespace configmgr { namespace backend {
  22
  23 namespace css = com::sun::star ;
  24 namespace uno = css::uno ;
  25 namespace lang = css::lang ;
  26 namespace backenduno = css::configuration::backend ;
  27
  28 /* Class containing a reference to a service factory(XSingleComponentFactory)
  29    object and a platform backend (XSingleLayerStratum).
  30    The reference to the platform backend will be NULL until the platform backend
  31    is initialised
  32  */
  33 class BackendRef
  34 {
  35     uno::Reference<lang::XSingleComponentFactory>  mFactory;
  36     uno::Reference<backenduno::XSingleLayerStratum> mBackend;
  37 public:
  38     explicit
  39     BackendRef(const uno::Reference<lang::XSingleComponentFactory>& aFactory)
  40     :mFactory(aFactory)
  41     ,mBackend()
  42     {}
  43
  44     uno::Reference<backenduno::XSingleLayerStratum> getBackend(uno::Reference<uno::XComponentContext> const & xContext);
  45     void disposeBackend();
  46 };
  47
  48 /**
  49   Class implementing the Backend service for system integration backend access.
  50   It creates the required backends and coordinates access to them.
  51   */
  52 class SystemIntegrationManager : public cppu::WeakComponentImplHelper4< backenduno::XBackend, backenduno::XBackendChangesNotifier, lang::XInitialization, lang::XServiceInfo>
  53 {
  54 public:
  55    /**
  56      Service constructor from a service factory.
  57
  58      @param xContext   component context
  59      */
  60     explicit
  61     SystemIntegrationManager( const uno::Reference<uno::XComponentContext>& xContext) ;
  62
  63     /** Destructor  */
  64     ~SystemIntegrationManager() ;
  65
  66     // XBackend
  67     virtual uno::Sequence<uno::Reference<backenduno::XLayer> >
  68         SAL_CALL listOwnLayers(const rtl::OUString& aComponent)
  69             throw (backenduno::BackendAccessException,
  70                     lang::IllegalArgumentException,
  71                     uno::RuntimeException) ;
  72
  73     virtual uno::Reference<backenduno::XUpdateHandler>
  74         SAL_CALL getOwnUpdateHandler(const rtl::OUString& aComponent)
  75         throw (backenduno::BackendAccessException,
  76                 lang::IllegalArgumentException,
  77                 lang::NoSupportException,
  78                 uno::RuntimeException) ;
  79
  80     virtual uno::Sequence<uno::Reference<backenduno::XLayer> > SAL_CALL
  81         listLayers(const rtl::OUString& aComponent,
  82                    const rtl::OUString& aEntity)
  83         throw (backenduno::BackendAccessException,
  84                 lang::IllegalArgumentException,
  85                 uno::RuntimeException) ;
  86
  87     virtual uno::Reference<backenduno::XUpdateHandler> SAL_CALL
  88         getUpdateHandler(const rtl::OUString& aComponent,
  89                          const rtl::OUString& aEntity)
  90         throw (backenduno::BackendAccessException,
  91                 lang::IllegalArgumentException,
  92                 lang::NoSupportException,
  93                 uno::RuntimeException) ;
  94
  95     // XInitialize
  96     virtual void SAL_CALL initialize(const uno::Sequence<uno::Any>& aParameters)
  97         throw (uno::RuntimeException, uno::Exception,
  98                lang::IllegalArgumentException,
  99                backenduno::BackendSetupException) ;
 100
 101    // XServiceInfo
 102     virtual rtl::OUString SAL_CALL getImplementationName()
 103         throw (uno::RuntimeException) ;
 104
 105     virtual sal_Bool SAL_CALL supportsService(const rtl::OUString& aServiceName)
 106         throw (uno::RuntimeException) ;
 107
 108     virtual uno::Sequence<rtl::OUString> SAL_CALL
 109         getSupportedServiceNames(void) throw (uno::RuntimeException) ;
 110
 111     // XBackendChangesNotifier
 112     virtual void SAL_CALL addChangesListener( const uno::Reference<backenduno::XBackendChangesListener>& xListner,
 113                                               const rtl::OUString& aComponent)
 114         throw (uno::RuntimeException);
 115
 116
 117     virtual void SAL_CALL removeChangesListener( const uno::Reference<backenduno::XBackendChangesListener>& xListner,
 118                                                  const rtl::OUString& aComponent)
 119         throw (uno::RuntimeException);
 120
 121      /**
 122       Provides the implementation name.
 123
 124       @return   implementation name
 125       */
 126     static rtl::OUString SAL_CALL getSystemIntegrationManagerName(void) ;
 127     /**
 128       Provides the list of supported services.
 129
 130       @return   list of service names
 131       */
 132     static uno::Sequence<rtl::OUString> SAL_CALL getServiceNames(void) ;
 133 protected:
 134 // ComponentHelper
 135     virtual void SAL_CALL disposing();
 136 private :
 137     /** build lookup up table
 138     */
 139     void buildLookupTable();
 140
 141     /** get list of supported components
 142     */
 143     uno::Sequence<rtl::OUString> getSupportedComponents(const uno::Reference<lang::XSingleComponentFactory>& xFactory);
 144
 145     /**
 146         get supporting backends from lookup table
 147     */
 148     std::vector< uno::Reference<backenduno::XSingleLayerStratum> > getSupportingBackends(const rtl::OUString& aComponent);
 149
 150 private :
 151     /** Mutex for resource protection */
 152     osl::Mutex mMutex ;
 153     /** Component Context */
 154     uno::Reference<uno::XComponentContext> mContext ;
 155
 156     std::multimap<rtl::OUString, BackendRef> mPlatformBackends;
 157 } ;
 158
 159 } }  // configmgr.backend
 160
 161 #endif // CONFIGMGR_BACKEND_SYSTEMINTEGRATIONMANAGER_HXX_