diff options
Diffstat (limited to 'extensions/source/inc')
| -rw-r--r-- | extensions/source/inc/componentmodule.cxx | 150 | ||||
| -rw-r--r-- | extensions/source/inc/componentmodule.hxx | 148 |
2 files changed, 298 insertions, 0 deletions
diff --git a/extensions/source/inc/componentmodule.cxx b/extensions/source/inc/componentmodule.cxx new file mode 100644 index 000000000..fa55250df --- /dev/null +++ b/extensions/source/inc/componentmodule.cxx @@ -0,0 +1,150 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include "componentmodule.hxx" +#include <unotools/resmgr.hxx> +#include <osl/diagnose.h> + +namespace compmodule +{ + using namespace ::com::sun::star::uno; + using namespace ::com::sun::star::lang; + using namespace ::com::sun::star::registry; + using namespace ::cppu; + + OUString ModuleRes(const char* pId) + { + return Translate::get(pId, Translate::Create("pcr")); + } + + //- registration helper + + std::vector< OUString >* OModule::s_pImplementationNames = nullptr; + std::vector< Sequence< OUString > >* OModule::s_pSupportedServices = nullptr; + std::vector< ComponentInstantiation >* OModule::s_pCreationFunctionPointers = nullptr; + std::vector< FactoryInstantiation >* OModule::s_pFactoryFunctionPointers = nullptr; + + + void OModule::registerComponent( + const OUString& _rImplementationName, + const Sequence< OUString >& _rServiceNames, + ComponentInstantiation _pCreateFunction, + FactoryInstantiation _pFactoryFunction) + { + if (!s_pImplementationNames) + { + OSL_ENSURE(!s_pSupportedServices && !s_pCreationFunctionPointers && !s_pFactoryFunctionPointers, + "OModule::registerComponent : inconsistent state (the pointers (1)) !"); + s_pImplementationNames = new std::vector< OUString >; + s_pSupportedServices = new std::vector< Sequence< OUString > >; + s_pCreationFunctionPointers = new std::vector< ComponentInstantiation >; + s_pFactoryFunctionPointers = new std::vector< FactoryInstantiation >; + } + OSL_ENSURE(s_pImplementationNames && s_pSupportedServices && s_pCreationFunctionPointers && s_pFactoryFunctionPointers, + "OModule::registerComponent : inconsistent state (the pointers (2)) !"); + + OSL_ENSURE( (s_pImplementationNames->size() == s_pSupportedServices->size()) + && (s_pImplementationNames->size() == s_pCreationFunctionPointers->size()) + && (s_pImplementationNames->size() == s_pFactoryFunctionPointers->size()), + "OModule::registerComponent : inconsistent state !"); + + s_pImplementationNames->push_back(_rImplementationName); + s_pSupportedServices->push_back(_rServiceNames); + s_pCreationFunctionPointers->push_back(_pCreateFunction); + s_pFactoryFunctionPointers->push_back(_pFactoryFunction); + } + + + void OModule::revokeComponent(const OUString& _rImplementationName) + { + if (!s_pImplementationNames) + { + OSL_FAIL("OModule::revokeComponent : have no class infos ! Are you sure called this method at the right time ?"); + return; + } + OSL_ENSURE(s_pImplementationNames && s_pSupportedServices && s_pCreationFunctionPointers && s_pFactoryFunctionPointers, + "OModule::revokeComponent : inconsistent state (the pointers) !"); + OSL_ENSURE( (s_pImplementationNames->size() == s_pSupportedServices->size()) + && (s_pImplementationNames->size() == s_pCreationFunctionPointers->size()) + && (s_pImplementationNames->size() == s_pFactoryFunctionPointers->size()), + "OModule::revokeComponent : inconsistent state !"); + + auto it = std::find(s_pImplementationNames->begin(), s_pImplementationNames->end(), _rImplementationName); + if (it != s_pImplementationNames->end()) + { + sal_Int32 i = static_cast<sal_Int32>(std::distance(s_pImplementationNames->begin(), it)); + s_pImplementationNames->erase(it); + s_pSupportedServices->erase(s_pSupportedServices->begin() + i); + s_pCreationFunctionPointers->erase(s_pCreationFunctionPointers->begin() + i); + s_pFactoryFunctionPointers->erase(s_pFactoryFunctionPointers->begin() + i); + } + + if (s_pImplementationNames->empty()) + { + delete s_pImplementationNames; s_pImplementationNames = nullptr; + delete s_pSupportedServices; s_pSupportedServices = nullptr; + delete s_pCreationFunctionPointers; s_pCreationFunctionPointers = nullptr; + delete s_pFactoryFunctionPointers; s_pFactoryFunctionPointers = nullptr; + } + } + + + Reference< XInterface > OModule::getComponentFactory( + const OUString& _rImplementationName, + const Reference< XMultiServiceFactory >& _rxServiceManager) + { + OSL_ENSURE(_rxServiceManager.is(), "OModule::getComponentFactory : invalid argument (service manager) !"); + OSL_ENSURE(!_rImplementationName.isEmpty(), "OModule::getComponentFactory : invalid argument (implementation name) !"); + + if (!s_pImplementationNames) + { + OSL_FAIL("OModule::getComponentFactory : have no class infos ! Are you sure called this method at the right time ?"); + return nullptr; + } + OSL_ENSURE(s_pImplementationNames && s_pSupportedServices && s_pCreationFunctionPointers && s_pFactoryFunctionPointers, + "OModule::getComponentFactory : inconsistent state (the pointers) !"); + OSL_ENSURE( (s_pImplementationNames->size() == s_pSupportedServices->size()) + && (s_pImplementationNames->size() == s_pCreationFunctionPointers->size()) + && (s_pImplementationNames->size() == s_pFactoryFunctionPointers->size()), + "OModule::getComponentFactory : inconsistent state !"); + + + sal_Int32 nLen = s_pImplementationNames->size(); + + for (sal_Int32 i=0; i<nLen; ++i) + { + if ((*s_pImplementationNames)[i] == _rImplementationName) + { + const FactoryInstantiation FactoryInstantiationFunction = (*s_pFactoryFunctionPointers)[i]; + + Reference< XInterface > xReturn = FactoryInstantiationFunction( _rxServiceManager, _rImplementationName, + (*s_pCreationFunctionPointers)[i], + (*s_pSupportedServices)[i], nullptr); + return xReturn; + } + } + + return nullptr; + } + + +} // namespace compmodule + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/extensions/source/inc/componentmodule.hxx b/extensions/source/inc/componentmodule.hxx new file mode 100644 index 000000000..d697ab866 --- /dev/null +++ b/extensions/source/inc/componentmodule.hxx @@ -0,0 +1,148 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_EXTENSIONS_SOURCE_INC_COMPONENTMODULE_HXX +#define INCLUDED_EXTENSIONS_SOURCE_INC_COMPONENTMODULE_HXX + +/** you may find this file helpful if you implement a component (in its own library) which can't use + the usual infrastructure.<br/> + More precise, you find helper classes to ease the use of resources and the registration of services. +*/ + +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <com/sun/star/lang/XSingleServiceFactory.hpp> +#include <com/sun/star/uno/Sequence.hxx> +#include <cppuhelper/factory.hxx> +#include <vector> + +namespace compmodule +{ + +typedef css::uno::Reference< css::lang::XSingleServiceFactory > (*FactoryInstantiation) + ( + const css::uno::Reference< css::lang::XMultiServiceFactory >& _rServiceManager, + const OUString & _rComponentName, + ::cppu::ComponentInstantiation _pCreateFunction, + const css::uno::Sequence< OUString > & _rServiceNames, + rtl_ModuleCount* + ); + + class OModule + { + private: + OModule() = delete; //TODO: get rid of this class + + protected: + // auto registration administration + static std::vector< OUString >* + s_pImplementationNames; + static std::vector< css::uno::Sequence< OUString > >* + s_pSupportedServices; + static std::vector< cppu::ComponentInstantiation >* + s_pCreationFunctionPointers; + static std::vector< FactoryInstantiation >* + s_pFactoryFunctionPointers; + + public: + /** register a component implementing a service with the given data. + @param _rImplementationName + the implementation name of the component + @param _rServiceNames + the services the component supports + @param _pCreateFunction + a function for creating an instance of the component + @param _pFactoryFunction + a function for creating a factory for that component + @see revokeComponent + */ + static void registerComponent( + const OUString& _rImplementationName, + const css::uno::Sequence< OUString >& _rServiceNames, + ::cppu::ComponentInstantiation _pCreateFunction, + FactoryInstantiation _pFactoryFunction); + + /** revoke the registration for the specified component + @param _rImplementationName + the implementation name of the component + */ + static void revokeComponent( + const OUString& _rImplementationName); + + /** creates a Factory for the component with the given implementation name. + <p>Usually used from within component_getFactory.<p/> + @param _rxServiceManager + a pointer to an XMultiServiceFactory interface as got in component_getFactory + @param _pImplementationName + the implementation name of the component + @return + the XInterface access to a factory for the component + */ + static css::uno::Reference< css::uno::XInterface > getComponentFactory( + const OUString& _rImplementationName, + const css::uno::Reference< css::lang::XMultiServiceFactory >& _rxServiceManager + ); + }; + + // specialized ResId, using the resource locale provided by the global module + OUString ModuleRes(const char* pId); + + template <class TYPE> + class OMultiInstanceAutoRegistration + { + public: + /** automatically registers a multi instance component + <p>Assumed that the template argument has the three methods + <ul> + <li><code>static OUString getImplementationName_Static()</code><li/> + <li><code>static css::uno::Sequence< OUString > getSupportedServiceNames_Static()</code><li/> + <li><code>static css::uno::Reference< css::uno::XInterface > + Create(const css::uno::Reference< css::lang::XMultiServiceFactory >&)</code> + </li> + <ul/> + the instantiation of this object will automatically register the class via <method>OModule::registerComponent</method>. + <p/> + The factory creation function used is <code>::cppu::createSingleFactory</code>. + */ + OMultiInstanceAutoRegistration(); + ~OMultiInstanceAutoRegistration(); + }; + + template <class TYPE> + OMultiInstanceAutoRegistration<TYPE>::OMultiInstanceAutoRegistration() + { + OModule::registerComponent( + TYPE::getImplementationName_Static(), + TYPE::getSupportedServiceNames_Static(), + TYPE::Create, + ::cppu::createSingleFactory + ); + } + + template <class TYPE> + OMultiInstanceAutoRegistration<TYPE>::~OMultiInstanceAutoRegistration() + { + OModule::revokeComponent(TYPE::getImplementationName_Static()); + } + +} // namespace compmodule + + +#endif // INCLUDED_EXTENSIONS_SOURCE_INC_COMPONENTMODULE_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |