/* -*- 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_COMPHELPER_SERVICEDECL_HXX #define INCLUDED_COMPHELPER_SERVICEDECL_HXX #include #include #include #include #include #include #include #include #include #include #include namespace comphelper { namespace service_decl { class ServiceDecl; namespace detail { typedef ::boost::function3< css::uno::Reference /* return */, ServiceDecl const&, css::uno::Sequence const&, css::uno::Reference const&> CreateFuncF; } /** Class to declare a service implementation. There is no need to implement lang::XServiceInfo nor lang::XInitialization anymore. The declaration can be done in various ways, the (simplest) form is
    class MyClass : public cppu::WeakImplHelper2 {
    public:
        MyClass( uno::Reference const& xContext )
        [...]
    };
    [...]
    namespace sdecl = comphelper::service_decl;
    sdecl::ServiceDecl const myDecl(
        sdecl::class_(),
        "my.unique.implementation.name",
        "MyServiceSpec1;MyServiceSpec2" );
    
If the service demands initialization by arguments, the implementation class has to define a constructor taking both arguments and component context:
    class MyClass : public cppu::WeakImplHelper2 {
    public:
        MyClass( uno::Sequence const& args,
                 uno::Reference const& xContext )
        [...]
    };
    [...]
    namespace sdecl = comphelper::service_decl;
    sdecl::ServiceDecl const myDecl(
        sdecl::class_ >(),
        "my.unique.implementation.name",
        "MyServiceSpec1;MyServiceSpec2" );
    
Additionally, there is the possibility to process some code after creation, e.g. to add the newly created object as a listener or perform aggregation (C++-UNO only):
    uno::Reference somePostProcCode( MyClass * p );
    [...]
    namespace sdecl = comphelper::service_decl;
    sdecl::ServiceDecl const myDecl(
        sdecl::class_(&somePostProcCode),
        "my.unique.implementation.name",
        "MyServiceSpec1;MyServiceSpec2" );
    
In the latter case, somePostProcCode gets the yet unacquired "raw" pointer. */ class COMPHELPER_DLLPUBLIC ServiceDecl : private ::boost::noncopyable { public: /** Ctor for multiple supported service names. @param implClass implementation class description @param pImplName implementation name @param pSupportedServiceNames supported service names @param cDelim delimiter for supported service names */ template ServiceDecl( ImplClassT const& implClass, char const* pImplName, char const* pSupportedServiceNames, char cDelim = ';' ) : m_createFunc(implClass.m_createFunc), m_pImplName(pImplName), m_pServiceNames(pSupportedServiceNames), m_cDelim(cDelim) {} /// @internal gets called by component_getFactoryHelper() void * getFactory( sal_Char const* pImplName ) const; /// @return supported service names ::com::sun::star::uno::Sequence< OUString> getSupportedServiceNames() const; /// @return whether name is in set of supported service names bool supportsService( OUString const& name ) const; /// @return implementation name OUString getImplementationName() const; private: class Factory; friend class Factory; detail::CreateFuncF const m_createFunc; char const* const m_pImplName; char const* const m_pServiceNames; char const m_cDelim; }; /** To specify whether the implementation class expects arguments (uno::Sequence). */ template struct with_args; /// @internal namespace detail { template class OwnServiceImpl : public ImplT, private ::boost::noncopyable { typedef ImplT BaseT; public: OwnServiceImpl( ServiceDecl const& rServiceDecl, css::uno::Sequence const& args, css::uno::Reference const& xContext ) :BaseT(args, xContext), m_rServiceDecl(rServiceDecl) {} OwnServiceImpl( ServiceDecl const& rServiceDecl, css::uno::Reference const& xContext ) : BaseT(xContext), m_rServiceDecl(rServiceDecl) {} // XServiceInfo virtual OUString SAL_CALL getImplementationName() throw (css::uno::RuntimeException) { return m_rServiceDecl.getImplementationName(); } virtual sal_Bool SAL_CALL supportsService( OUString const& name ) throw (css::uno::RuntimeException) { return m_rServiceDecl.supportsService(name); } virtual css::uno::Sequence< OUString> SAL_CALL getSupportedServiceNames() throw (css::uno::RuntimeException) { return m_rServiceDecl.getSupportedServiceNames(); } private: ServiceDecl const& m_rServiceDecl; }; template class ServiceImpl : public OwnServiceImpl< ::cppu::ImplInheritanceHelper1 > { typedef OwnServiceImpl< ::cppu::ImplInheritanceHelper1 > ServiceImpl_BASE; public: ServiceImpl( ServiceDecl const& rServiceDecl, css::uno::Sequence const& args, css::uno::Reference const& xContext ) : ServiceImpl_BASE(rServiceDecl, args, xContext) {} ServiceImpl( ServiceDecl const& rServiceDecl, css::uno::Reference const& xContext ) : ServiceImpl_BASE(rServiceDecl, xContext) {} }; template struct PostProcessDefault { css::uno::Reference operator()( ServiceImplT * p ) const { return static_cast(p); } }; template struct CreateFunc; template struct CreateFunc > { PostProcessFuncT const m_postProcessFunc; explicit CreateFunc( PostProcessFuncT const& postProcessFunc ) : m_postProcessFunc(postProcessFunc) {} css::uno::Reference operator()( ServiceDecl const& rServiceDecl, css::uno::Sequence const&, css::uno::Reference const& xContext ) const { return m_postProcessFunc( new ImplT( rServiceDecl, xContext ) ); } }; template struct CreateFunc > { PostProcessFuncT const m_postProcessFunc; explicit CreateFunc( PostProcessFuncT const& postProcessFunc ) : m_postProcessFunc(postProcessFunc) {} css::uno::Reference operator()( ServiceDecl const& rServiceDecl, css::uno::Sequence const& args, css::uno::Reference const& xContext ) const { return m_postProcessFunc( new ImplT( rServiceDecl, args, xContext ) ); } }; } // namespace detail /** Defines a service implementation class. @tpl ImplT_ service implementation class @WithArgsT whether the implementation class ctor expects arguments (uno::Sequence, uno::Reference) or just (uno::Reference) */ template > struct serviceimpl_base { typedef ImplT_ ImplT; detail::CreateFuncF const m_createFunc; typedef detail::PostProcessDefault PostProcessDefaultT; /** Default ctor. Implementation class without args, expecting component context as single argument. */ serviceimpl_base() : m_createFunc( detail::CreateFunc( PostProcessDefaultT() ) ) {} /** Ctor to pass a post processing function/functor. @tpl PostProcessDefaultT let your compiler deduce this @param postProcessFunc function/functor that gets the yet unacquired ImplT_ pointer returning a uno::Reference */ template explicit serviceimpl_base( PostProcessFuncT const& postProcessFunc ) : m_createFunc( detail::CreateFunc( postProcessFunc ) ) {} }; template > struct class_ : public serviceimpl_base< detail::ServiceImpl, WithArgsT > { typedef serviceimpl_base< detail::ServiceImpl, WithArgsT > baseT; /** Default ctor. Implementation class without args, expecting component context as single argument. */ class_() : baseT() {} template /** Ctor to pass a post processing function/functor. @tpl PostProcessDefaultT let your compiler deduce this @param postProcessFunc function/functor that gets the yet unacquired ImplT_ pointer returning a uno::Reference */ explicit class_( PostProcessFuncT const& postProcessFunc ) : baseT( postProcessFunc ) {} }; // // component_... helpers with arbitrary service declarations: // #define COMPHELPER_SERVICEDECL_getFactory(z_, n_, unused_) \ if (pRet == 0) \ pRet = BOOST_PP_CAT(s, n_).getFactory(pImplName); /** The following preprocessor repetitions generate functions like
        inline void * component_getFactoryHelper(
            sal_Char const* pImplName,
            ::com::sun::star::lang::XMultiServiceFactory *,
            ::com::sun::star::registry::XRegistryKey * xRegistryKey,
            ServiceDecl const& s0, ServiceDecl const& s1, ... );
    
which call on the passed service declarations. The maximum number of service declarations can be set by defining COMPHELPER_SERVICEDECL_COMPONENT_HELPER_MAX_ARGS; its default is 8. */ #define COMPHELPER_SERVICEDECL_make(z_, n_, unused_) \ inline void * component_getFactoryHelper( \ sal_Char const* pImplName, \ ::com::sun::star::lang::XMultiServiceFactory *, \ ::com::sun::star::registry::XRegistryKey *, \ BOOST_PP_ENUM_PARAMS(n_, ServiceDecl const& s) ) \ { \ void * pRet = 0; \ BOOST_PP_REPEAT(n_, COMPHELPER_SERVICEDECL_getFactory, ~) \ return pRet; \ } #ifndef COMPHELPER_SERVICEDECL_COMPONENT_HELPER_MAX_ARGS #define COMPHELPER_SERVICEDECL_COMPONENT_HELPER_MAX_ARGS 8 #endif BOOST_PP_REPEAT_FROM_TO(1, COMPHELPER_SERVICEDECL_COMPONENT_HELPER_MAX_ARGS, COMPHELPER_SERVICEDECL_make, ~) #undef COMPHELPER_SERVICEDECL_COMPONENT_HELPER_MAX_ARGS #undef COMPHELPER_SERVICEDECL_make #undef COMPHELPER_SERVICEDECL_getFactory } // namespace service_decl } // namespace comphelper /** The following preprocessor macro generates the C access functions, that are used to initialize and register the components of a shared library object. If you have, say, written a lib that contains three distinct components, each with its own ServiceDecl object, you might want to employ the following code:
        // must reside outside _any_ namespace
        COMPHELPER_SERVICEDECL_EXPORTS3(yourServiceDecl1,
                                       yourServiceDecl2,
                                       yourServiceDecl3);
    
For your convenience, the COMPHELPER_SERVICEDECL_EXPORTS macro comes pre-defined up to N=8, if you should need more arguments, call COMPHELPER_SERVICEDECL_make_exports directly, like this:
        // must reside outside _any_ namespace
        COMPHELPER_SERVICEDECL_make_exports((yourServiceDecl1)(yourServiceDecl2)...(yourServiceDeclN));
    
Note the missing colons between the bracketed arguments. */ #define COMPHELPER_SERVICEDECL_make_exports(compName, varargs_ ) \ extern "C" \ { \ SAL_DLLPUBLIC_EXPORT void* SAL_CALL compName##_component_getFactory( sal_Char const* pImplName, \ ::com::sun::star::lang::XMultiServiceFactory* pServiceManager, \ ::com::sun::star::registry::XRegistryKey* pRegistryKey ) \ { \ return component_getFactoryHelper( pImplName, pServiceManager, \ pRegistryKey, \ BOOST_PP_SEQ_ENUM(varargs_) ); \ } \ } #define COMPHELPER_SERVICEDECL_EXPORTS1(compName,comp0_) \ COMPHELPER_SERVICEDECL_make_exports(compName,(comp0_)) #define COMPHELPER_SERVICEDECL_EXPORTS2(compName,comp0_,comp1_) \ COMPHELPER_SERVICEDECL_make_exports(compName,(comp0_)(comp1_)) #define COMPHELPER_SERVICEDECL_EXPORTS3(compName,comp0_,comp1_,comp2_) \ COMPHELPER_SERVICEDECL_make_exports(compName,(comp0_)(comp1_)(comp2_)) #define COMPHELPER_SERVICEDECL_EXPORTS4(compName,comp0_,comp1_,comp2_,comp3_) \ COMPHELPER_SERVICEDECL_make_exports(compName,(comp0_)(comp1_)(comp2_)(comp3_)) #define COMPHELPER_SERVICEDECL_EXPORTS5(compName,comp0_,comp1_,comp2_,comp3_,comp4_) \ COMPHELPER_SERVICEDECL_make_exports(compName,(comp0_)(comp1_)(comp2_)(comp3_)(comp4_)) #define COMPHELPER_SERVICEDECL_EXPORTS6(compName,comp0_,comp1_,comp2_,comp3_,comp4_,comp5_) \ COMPHELPER_SERVICEDECL_make_exports(compName,(comp0_)(comp1_)(comp2_)(comp3_)(comp4_)(comp5_)) #define COMPHELPER_SERVICEDECL_EXPORTS7(compName,comp0_,comp1_,comp2_,comp3_,comp4_,comp5_,comp6_) \ COMPHELPER_SERVICEDECL_make_exports(compName,(comp0_)(comp1_)(comp2_)(comp3_)(comp4_)(comp5_)(comp6_)) #define COMPHELPER_SERVICEDECL_EXPORTS8(compName,comp0_,comp1_,comp2_,comp3_,comp4_,comp5_,comp6_,comp7_) \ COMPHELPER_SERVICEDECL_make_exports(compName,(comp0_)(comp1_)(comp2_)(comp3_)(comp4_)(comp5_)(comp6_)(comp7_)) #endif // ! defined( INCLUDED_COMPHELPER_SERVICEDECL_HXX) /* vim:set shiftwidth=4 softtabstop=4 expandtab: */