extensions/source/inc/componentmodule.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: componentmodule.cxx,v $
  10  * $Revision: 1.7 $
  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 #include "componentmodule.hxx"
  32 #include <tools/resmgr.hxx>
  33 #ifndef _SOLAR_HRC
  34 #include <svtools/solar.hrc>
  35 #endif
  36 #include <comphelper/sequence.hxx>
  37 #include <tools/debug.hxx>
  38
  39 #define ENTER_MOD_METHOD()      \
  40     ::osl::MutexGuard aGuard(s_aMutex); \
  41     ensureImpl()
  42
  43 //.........................................................................
  44 namespace COMPMOD_NAMESPACE
  45 {
  46 //.........................................................................
  47
  48     using namespace ::com::sun::star::uno;
  49     using namespace ::com::sun::star::lang;
  50     using namespace ::com::sun::star::registry;
  51     using namespace ::comphelper;
  52     using namespace ::cppu;
  53
  54     //=========================================================================
  55     //= OModuleImpl
  56     //=========================================================================
  57     /** implementation for <type>OModule</type>. not threadsafe, has to be guarded by it's owner
  58     */
  59     class OModuleImpl
  60     {
  61         ResMgr*         m_pRessources;
  62         sal_Bool        m_bInitialized;
  63         ByteString      m_sFilePrefix;
  64
  65     public:
  66         /// ctor
  67         OModuleImpl();
  68         ~OModuleImpl();
  69
  70         /// get the manager for the ressources of the module
  71         ResMgr* getResManager();
  72         void    setResourceFilePrefix(const ::rtl::OString& _rPrefix) { m_sFilePrefix = _rPrefix; }
  73     };
  74
  75     //-------------------------------------------------------------------------
  76     OModuleImpl::OModuleImpl()
  77         :m_pRessources(NULL)
  78         ,m_bInitialized(sal_False)
  79     {
  80     }
  81
  82     //-------------------------------------------------------------------------
  83     OModuleImpl::~OModuleImpl()
  84     {
  85         if (m_pRessources)
  86             delete m_pRessources;
  87     }
  88
  89     //-------------------------------------------------------------------------
  90     ResMgr*     OModuleImpl::getResManager()
  91     {
  92         // note that this method is not threadsafe, which counts for the whole class !
  93         if (!m_pRessources && !m_bInitialized)
  94         {
  95             DBG_ASSERT(m_sFilePrefix.Len(), "OModuleImpl::getResManager: no resource file prefix!");
  96             // create a manager with a fixed prefix
  97             ByteString aMgrName = m_sFilePrefix;
  98
  99             m_pRessources = ResMgr::CreateResMgr(aMgrName.GetBuffer());
 100             DBG_ASSERT(m_pRessources,
 101                     (ByteString("OModuleImpl::getResManager: could not create the resource manager (file name: ")
 102                 +=      aMgrName
 103                 +=      ByteString(")!")).GetBuffer());
 104
 105             m_bInitialized = sal_True;
 106         }
 107         return m_pRessources;
 108     }
 109
 110     //=========================================================================
 111     //= OModule
 112     //=========================================================================
 113     ::osl::Mutex        OModule::s_aMutex;
 114     sal_Int32           OModule::s_nClients = 0;
 115     OModuleImpl*        OModule::s_pImpl = NULL;
 116     ::rtl::OString      OModule::s_sResPrefix;
 117     //-------------------------------------------------------------------------
 118     ResMgr*     OModule::getResManager()
 119     {
 120         ENTER_MOD_METHOD();
 121         return s_pImpl->getResManager();
 122     }
 123
 124     //-------------------------------------------------------------------------
 125     void OModule::setResourceFilePrefix(const ::rtl::OString& _rPrefix)
 126     {
 127         ::osl::MutexGuard aGuard(s_aMutex);
 128         s_sResPrefix = _rPrefix;
 129         if (s_pImpl)
 130             s_pImpl->setResourceFilePrefix(_rPrefix);
 131     }
 132
 133     //-------------------------------------------------------------------------
 134     void OModule::registerClient()
 135     {
 136         ::osl::MutexGuard aGuard(s_aMutex);
 137         ++s_nClients;
 138     }
 139
 140     //-------------------------------------------------------------------------
 141     void OModule::revokeClient()
 142     {
 143         ::osl::MutexGuard aGuard(s_aMutex);
 144         if (!--s_nClients && s_pImpl)
 145         {
 146             delete s_pImpl;
 147             s_pImpl = NULL;
 148         }
 149     }
 150
 151     //-------------------------------------------------------------------------
 152     void OModule::ensureImpl()
 153     {
 154         if (s_pImpl)
 155             return;
 156         s_pImpl = new OModuleImpl();
 157         s_pImpl->setResourceFilePrefix(s_sResPrefix);
 158     }
 159
 160     //--------------------------------------------------------------------------
 161     //- registration helper
 162     //--------------------------------------------------------------------------
 163
 164     Sequence< ::rtl::OUString >*                                OModule::s_pImplementationNames = NULL;
 165     Sequence< Sequence< ::rtl::OUString > >*    OModule::s_pSupportedServices = NULL;
 166     Sequence< sal_Int64 >*                                              OModule::s_pCreationFunctionPointers = NULL;
 167     Sequence< sal_Int64 >*                                              OModule::s_pFactoryFunctionPointers = NULL;
 168
 169     //--------------------------------------------------------------------------
 170     void OModule::registerComponent(
 171         const ::rtl::OUString& _rImplementationName,
 172         const Sequence< ::rtl::OUString >& _rServiceNames,
 173         ComponentInstantiation _pCreateFunction,
 174         FactoryInstantiation _pFactoryFunction)
 175     {
 176         if (!s_pImplementationNames)
 177         {
 178             OSL_ENSURE(!s_pSupportedServices && !s_pCreationFunctionPointers && !s_pFactoryFunctionPointers,
 179                 "OModule::registerComponent : inconsistent state (the pointers (1)) !");
 180             s_pImplementationNames = new Sequence< ::rtl::OUString >;
 181             s_pSupportedServices = new Sequence< Sequence< ::rtl::OUString > >;
 182             s_pCreationFunctionPointers = new Sequence< sal_Int64 >;
 183             s_pFactoryFunctionPointers = new Sequence< sal_Int64 >;
 184         }
 185         OSL_ENSURE(s_pImplementationNames && s_pSupportedServices && s_pCreationFunctionPointers && s_pFactoryFunctionPointers,
 186             "OModule::registerComponent : inconsistent state (the pointers (2)) !");
 187
 188         OSL_ENSURE(     (s_pImplementationNames->getLength() == s_pSupportedServices->getLength())
 189                     &&  (s_pImplementationNames->getLength() == s_pCreationFunctionPointers->getLength())
 190                     &&  (s_pImplementationNames->getLength() == s_pFactoryFunctionPointers->getLength()),
 191             "OModule::registerComponent : inconsistent state !");
 192
 193         sal_Int32 nOldLen = s_pImplementationNames->getLength();
 194         s_pImplementationNames->realloc(nOldLen + 1);
 195         s_pSupportedServices->realloc(nOldLen + 1);
 196         s_pCreationFunctionPointers->realloc(nOldLen + 1);
 197         s_pFactoryFunctionPointers->realloc(nOldLen + 1);
 198
 199         s_pImplementationNames->getArray()[nOldLen] = _rImplementationName;
 200         s_pSupportedServices->getArray()[nOldLen] = _rServiceNames;
 201         s_pCreationFunctionPointers->getArray()[nOldLen] = reinterpret_cast<sal_Int64>(_pCreateFunction);
 202         s_pFactoryFunctionPointers->getArray()[nOldLen] = reinterpret_cast<sal_Int64>(_pFactoryFunction);
 203     }
 204
 205     //--------------------------------------------------------------------------
 206     void OModule::revokeComponent(const ::rtl::OUString& _rImplementationName)
 207     {
 208         if (!s_pImplementationNames)
 209         {
 210             OSL_ASSERT("OModule::revokeComponent : have no class infos ! Are you sure called this method at the right time ?");
 211             return;
 212         }
 213         OSL_ENSURE(s_pImplementationNames && s_pSupportedServices && s_pCreationFunctionPointers && s_pFactoryFunctionPointers,
 214             "OModule::revokeComponent : inconsistent state (the pointers) !");
 215         OSL_ENSURE(     (s_pImplementationNames->getLength() == s_pSupportedServices->getLength())
 216                     &&  (s_pImplementationNames->getLength() == s_pCreationFunctionPointers->getLength())
 217                     &&  (s_pImplementationNames->getLength() == s_pFactoryFunctionPointers->getLength()),
 218             "OModule::revokeComponent : inconsistent state !");
 219
 220         sal_Int32 nLen = s_pImplementationNames->getLength();
 221         const ::rtl::OUString* pImplNames = s_pImplementationNames->getConstArray();
 222         for (sal_Int32 i=0; i<nLen; ++i, ++pImplNames)
 223         {
 224             if (pImplNames->equals(_rImplementationName))
 225             {
 226                 removeElementAt(*s_pImplementationNames, i);
 227                 removeElementAt(*s_pSupportedServices, i);
 228                 removeElementAt(*s_pCreationFunctionPointers, i);
 229                 removeElementAt(*s_pFactoryFunctionPointers, i);
 230                 break;
 231             }
 232         }
 233
 234         if (s_pImplementationNames->getLength() == 0)
 235         {
 236             delete s_pImplementationNames; s_pImplementationNames = NULL;
 237             delete s_pSupportedServices; s_pSupportedServices = NULL;
 238             delete s_pCreationFunctionPointers; s_pCreationFunctionPointers = NULL;
 239             delete s_pFactoryFunctionPointers; s_pFactoryFunctionPointers = NULL;
 240         }
 241     }
 242
 243     //--------------------------------------------------------------------------
 244     sal_Bool OModule::writeComponentInfos(
 245             const Reference< XMultiServiceFactory >& /*_rxServiceManager*/,
 246             const Reference< XRegistryKey >& _rxRootKey)
 247     {
 248         OSL_ENSURE(_rxRootKey.is(), "OModule::writeComponentInfos : invalid argument !");
 249
 250         if (!s_pImplementationNames)
 251         {
 252             OSL_ASSERT("OModule::writeComponentInfos : have no class infos ! Are you sure called this method at the right time ?");
 253             return sal_True;
 254         }
 255         OSL_ENSURE(s_pImplementationNames && s_pSupportedServices && s_pCreationFunctionPointers && s_pFactoryFunctionPointers,
 256             "OModule::writeComponentInfos : inconsistent state (the pointers) !");
 257         OSL_ENSURE(     (s_pImplementationNames->getLength() == s_pSupportedServices->getLength())
 258                     &&  (s_pImplementationNames->getLength() == s_pCreationFunctionPointers->getLength())
 259                     &&  (s_pImplementationNames->getLength() == s_pFactoryFunctionPointers->getLength()),
 260             "OModule::writeComponentInfos : inconsistent state !");
 261
 262         sal_Int32 nLen = s_pImplementationNames->getLength();
 263         const ::rtl::OUString* pImplName = s_pImplementationNames->getConstArray();
 264         const Sequence< ::rtl::OUString >* pServices = s_pSupportedServices->getConstArray();
 265
 266         ::rtl::OUString sRootKey("/", 1, RTL_TEXTENCODING_ASCII_US);
 267         for (sal_Int32 i=0; i<nLen; ++i, ++pImplName, ++pServices)
 268         {
 269             ::rtl::OUString aMainKeyName(sRootKey);
 270             aMainKeyName += *pImplName;
 271             aMainKeyName += ::rtl::OUString::createFromAscii("/UNO/SERVICES");
 272
 273             try
 274             {
 275                 Reference< XRegistryKey >  xNewKey( _rxRootKey->createKey(aMainKeyName) );
 276
 277                 const ::rtl::OUString* pService = pServices->getConstArray();
 278                 for (sal_Int32 j=0; j<pServices->getLength(); ++j, ++pService)
 279                     xNewKey->createKey(*pService);
 280             }
 281             catch(Exception&)
 282             {
 283                 OSL_ASSERT("OModule::writeComponentInfos : something went wrong while creating the keys !");
 284                 return sal_False;
 285             }
 286         }
 287
 288         return sal_True;
 289     }
 290
 291     //--------------------------------------------------------------------------
 292     Reference< XInterface > OModule::getComponentFactory(
 293         const ::rtl::OUString& _rImplementationName,
 294         const Reference< XMultiServiceFactory >& _rxServiceManager)
 295     {
 296         OSL_ENSURE(_rxServiceManager.is(), "OModule::getComponentFactory : invalid argument (service manager) !");
 297         OSL_ENSURE(_rImplementationName.getLength(), "OModule::getComponentFactory : invalid argument (implementation name) !");
 298
 299         if (!s_pImplementationNames)
 300         {
 301             OSL_ASSERT("OModule::getComponentFactory : have no class infos ! Are you sure called this method at the right time ?");
 302             return NULL;
 303         }
 304         OSL_ENSURE(s_pImplementationNames && s_pSupportedServices && s_pCreationFunctionPointers && s_pFactoryFunctionPointers,
 305             "OModule::getComponentFactory : inconsistent state (the pointers) !");
 306         OSL_ENSURE(     (s_pImplementationNames->getLength() == s_pSupportedServices->getLength())
 307                     &&  (s_pImplementationNames->getLength() == s_pCreationFunctionPointers->getLength())
 308                     &&  (s_pImplementationNames->getLength() == s_pFactoryFunctionPointers->getLength()),
 309             "OModule::getComponentFactory : inconsistent state !");
 310
 311
 312         Reference< XInterface > xReturn;
 313
 314
 315         sal_Int32 nLen = s_pImplementationNames->getLength();
 316         const ::rtl::OUString* pImplName = s_pImplementationNames->getConstArray();
 317         const Sequence< ::rtl::OUString >* pServices = s_pSupportedServices->getConstArray();
 318         const sal_Int64* pComponentFunction = s_pCreationFunctionPointers->getConstArray();
 319         const sal_Int64* pFactoryFunction = s_pFactoryFunctionPointers->getConstArray();
 320
 321         for (sal_Int32 i=0; i<nLen; ++i, ++pImplName, ++pServices, ++pComponentFunction, ++pFactoryFunction)
 322         {
 323             if (pImplName->equals(_rImplementationName))
 324             {
 325                 const FactoryInstantiation FactoryInstantiationFunction = reinterpret_cast<const FactoryInstantiation>(*pFactoryFunction);
 326                 const ComponentInstantiation ComponentInstantiationFunction = reinterpret_cast<const ComponentInstantiation>(*pComponentFunction);
 327
 328                 xReturn = FactoryInstantiationFunction( _rxServiceManager, *pImplName, ComponentInstantiationFunction, *pServices, NULL);
 329                 if (xReturn.is())
 330                 {
 331                     xReturn->acquire();
 332                     return xReturn.get();
 333                 }
 334             }
 335         }
 336
 337         return NULL;
 338     }
 339
 340
 341 //.........................................................................
 342 }       // namespace COMPMOD_NAMESPACE
 343 //.........................................................................
 344