/* -*- 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 namespace comphelper { namespace service_decl { class ServiceDecl; namespace detail { typedef ::std::function< 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::WeakImplHelper {
    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::WeakImplHelper {
    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 { 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 */ ServiceDecl( const ServiceDecl& ) = delete; ServiceDecl& operator=( const ServiceDecl& ) = delete; template ServiceDecl( ImplClassT const& implClass, char const* pImplName, char const* pSupportedServiceNames ) : m_createFunc(implClass.m_createFunc), m_pImplName(pImplName), m_pServiceNames(pSupportedServiceNames) {} /// @internal gets called by component_getFactoryHelper() void * getFactory( char const* pImplName ) const; /// @return supported service names css::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; }; /** To specify whether the implementation class expects arguments (uno::Sequence). */ template struct with_args; /// @internal namespace detail { template class OwnServiceImpl : public ImplT { typedef ImplT BaseT; public: OwnServiceImpl( const OwnServiceImpl& ) = delete; OwnServiceImpl& operator=( const OwnServiceImpl& ) = delete; 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() override { return m_rServiceDecl.getImplementationName(); } virtual sal_Bool SAL_CALL supportsService( OUString const& name ) override { return m_rServiceDecl.supportsService(name); } virtual css::uno::Sequence< OUString> SAL_CALL getSupportedServiceNames() override { return m_rServiceDecl.getSupportedServiceNames(); } private: ServiceDecl const& m_rServiceDecl; }; template class ServiceImpl final : public OwnServiceImpl< ::cppu::ImplInheritanceHelper > { typedef OwnServiceImpl< ::cppu::ImplInheritanceHelper > 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 class InheritingServiceImpl final : public OwnServiceImpl< ImplT > { typedef OwnServiceImpl< ImplT > ServiceImpl_BASE; public: InheritingServiceImpl( ServiceDecl const& rServiceDecl, css::uno::Sequence const& args, css::uno::Reference const& xContext ) : ServiceImpl_BASE(rServiceDecl, args, 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 ) {} }; template > struct inheritingClass_ : public serviceimpl_base< detail::InheritingServiceImpl, WithArgsT > { typedef serviceimpl_base< detail::InheritingServiceImpl, WithArgsT > baseT; /** Default ctor. Implementation class without args, expecting component context as single argument. */ inheritingClass_() : 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 inheritingClass_( PostProcessFuncT const& postProcessFunc ) : baseT( postProcessFunc ) {} }; COMPHELPER_DLLPUBLIC void* component_getFactoryHelper( const char* pImplName, std::initializer_list args ); } // namespace service_decl } // namespace comphelper #endif // ! defined( INCLUDED_COMPHELPER_SERVICEDECL_HXX) /* vim:set shiftwidth=4 softtabstop=4 expandtab: */