office-gobmx/include/comphelper/servicedecl.hxx
Bjoern Michaelsen b9337e22ce execute move of global headers
see https://gerrit.libreoffice.org/#/c/3367/
and Change-Id: I00c96fa77d04b33a6f8c8cd3490dfcd9bdc9e84a for details

Change-Id: I199a75bc4042af20817265d5ef85b1134a96ff5a
2013-04-23 22:20:31 +02:00

409 lines
15 KiB
C++

/* -*- 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 COMPHELPER_SERVICEDECL_HXX_INCLUDED
#define COMPHELPER_SERVICEDECL_HXX_INCLUDED
#include <comphelper/comphelperdllapi.h>
#include <cppuhelper/implbase1.hxx>
#include <com/sun/star/uno/XComponentContext.hpp>
#include <com/sun/star/lang/XServiceInfo.hpp>
#include <com/sun/star/registry/XRegistryKey.hpp>
#include <uno/environment.h>
#include <boost/utility.hpp>
#include <boost/function.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/repetition.hpp>
#include <boost/preprocessor/seq/enum.hpp>
namespace comphelper {
namespace service_decl {
class ServiceDecl;
namespace detail {
typedef ::boost::function3<
css::uno::Reference<css::uno::XInterface> /* return */,
ServiceDecl const&,
css::uno::Sequence<css::uno::Any> const&,
css::uno::Reference<css::uno::XComponentContext> 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
<pre>
class MyClass : public cppu::WeakImplHelper2<XInterface1, XInterface2> {
public:
MyClass( uno::Reference<uno::XComponentContext> const& xContext )
[...]
};
[...]
namespace sdecl = comphelper::service_decl;
sdecl::ServiceDecl const myDecl(
sdecl::class_<MyClass>(),
"my.unique.implementation.name",
"MyServiceSpec1;MyServiceSpec2" );
</pre>
If the service demands initialization by arguments, the implementation
class has to define a constructor taking both arguments and component
context:
<pre>
class MyClass : public cppu::WeakImplHelper2<XInterface1, XInterface2> {
public:
MyClass( uno::Sequence<uno::Any> const& args,
uno::Reference<uno:XComponentContext> const& xContext )
[...]
};
[...]
namespace sdecl = comphelper::service_decl;
sdecl::ServiceDecl const myDecl(
sdecl::class_<MyClass, sdecl::with_args<true> >(),
"my.unique.implementation.name",
"MyServiceSpec1;MyServiceSpec2" );
</pre>
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):
<pre>
uno::Reference<uno::XInterface> somePostProcCode( MyClass * p );
[...]
namespace sdecl = comphelper::service_decl;
sdecl::ServiceDecl const myDecl(
sdecl::class_<MyClass, ... >(&somePostProcCode),
"my.unique.implementation.name",
"MyServiceSpec1;MyServiceSpec2" );
</pre>
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 <typename ImplClassT>
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<uno::Any>).
*/
template <bool> struct with_args;
/// @internal
namespace detail {
template <typename ImplT>
class OwnServiceImpl
: public ImplT,
private ::boost::noncopyable
{
typedef ImplT BaseT;
public:
OwnServiceImpl(
ServiceDecl const& rServiceDecl,
css::uno::Sequence<css::uno::Any> const& args,
css::uno::Reference<css::uno::XComponentContext> const& xContext )
:BaseT(args, xContext), m_rServiceDecl(rServiceDecl) {}
OwnServiceImpl(
ServiceDecl const& rServiceDecl,
css::uno::Reference<css::uno::XComponentContext> 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 <typename ImplT>
class ServiceImpl : public OwnServiceImpl< ::cppu::ImplInheritanceHelper1<ImplT,css::lang::XServiceInfo> >
{
typedef OwnServiceImpl< ::cppu::ImplInheritanceHelper1<ImplT,css::lang::XServiceInfo> > ServiceImpl_BASE;
public:
ServiceImpl(
ServiceDecl const& rServiceDecl,
css::uno::Sequence<css::uno::Any> const& args,
css::uno::Reference<css::uno::XComponentContext> const& xContext )
: ServiceImpl_BASE(rServiceDecl, args, xContext) {}
ServiceImpl(
ServiceDecl const& rServiceDecl,
css::uno::Reference<css::uno::XComponentContext> const& xContext )
: ServiceImpl_BASE(rServiceDecl, xContext) {}
};
template <typename ServiceImplT>
struct PostProcessDefault {
css::uno::Reference<css::uno::XInterface>
operator()( ServiceImplT * p ) const {
return static_cast<css::lang::XServiceInfo *>(p);
}
};
template <typename ImplT, typename PostProcessFuncT, typename WithArgsT>
struct CreateFunc;
template <typename ImplT, typename PostProcessFuncT>
struct CreateFunc<ImplT, PostProcessFuncT, with_args<false> > {
PostProcessFuncT const m_postProcessFunc;
explicit CreateFunc( PostProcessFuncT const& postProcessFunc )
: m_postProcessFunc(postProcessFunc) {}
css::uno::Reference<css::uno::XInterface>
operator()( ServiceDecl const& rServiceDecl,
css::uno::Sequence<css::uno::Any> const&,
css::uno::Reference<css::uno::XComponentContext>
const& xContext ) const
{
return m_postProcessFunc(
new ImplT( rServiceDecl, xContext ) );
}
};
template <typename ImplT, typename PostProcessFuncT>
struct CreateFunc<ImplT, PostProcessFuncT, with_args<true> > {
PostProcessFuncT const m_postProcessFunc;
explicit CreateFunc( PostProcessFuncT const& postProcessFunc )
: m_postProcessFunc(postProcessFunc) {}
css::uno::Reference<css::uno::XInterface>
operator()( ServiceDecl const& rServiceDecl,
css::uno::Sequence<css::uno::Any> const& args,
css::uno::Reference<css::uno::XComponentContext>
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::Any>, uno::Reference<uno::XComponentContext>)
or just (uno::Reference<uno::XComponentContext>)
*/
template <typename ImplT_, typename WithArgsT = with_args<false> >
struct serviceimpl_base {
typedef ImplT_ ImplT;
detail::CreateFuncF const m_createFunc;
typedef detail::PostProcessDefault<ImplT> PostProcessDefaultT;
/** Default ctor. Implementation class without args, expecting
component context as single argument.
*/
serviceimpl_base() : m_createFunc(
detail::CreateFunc<ImplT, PostProcessDefaultT, WithArgsT>(
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<uno::XInterface>
*/
template <typename PostProcessFuncT>
explicit serviceimpl_base( PostProcessFuncT const& postProcessFunc )
: m_createFunc( detail::CreateFunc<ImplT, PostProcessFuncT, WithArgsT>(
postProcessFunc ) ) {}
};
template <typename ImplT_, typename WithArgsT = with_args<false> >
struct class_ : public serviceimpl_base< detail::ServiceImpl<ImplT_>, WithArgsT >
{
typedef serviceimpl_base< detail::ServiceImpl<ImplT_>, WithArgsT > baseT;
/** Default ctor. Implementation class without args, expecting
component context as single argument.
*/
class_() : baseT() {}
template <typename PostProcessFuncT>
/** 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<uno::XInterface>
*/
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
<pre>
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, ... );
</pre>
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:
<pre>
// must reside outside _any_ namespace
COMPHELPER_SERVICEDECL_EXPORTS3(yourServiceDecl1,
yourServiceDecl2,
yourServiceDecl3);
</pre>
For your convenience, the COMPHELPER_SERVICEDECL_EXPORTS<N> macro
comes pre-defined up to N=8, if you should need more arguments,
call COMPHELPER_SERVICEDECL_make_exports directly, like this:
<pre>
// must reside outside _any_ namespace
COMPHELPER_SERVICEDECL_make_exports((yourServiceDecl1)(yourServiceDecl2)...(yourServiceDeclN));
</pre>
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(COMPHELPER_SERVICEDECL_HXX_INCLUDED)
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */