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