[libt2n] / src / client_wrapper.hxx

/***************************************************************************
 *   Copyright (C) 2008 by Gerd v. Egidy and Reinhard Pfau                 *
 *   gve@intra2net.com                                                     *
 *                                                                         *
 *   This library is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU Lesser General Public License version   *
 *   2.1 as published by the Free Software Foundation.                     *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU Lesser General Public License for more details.                   *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this program; if not, write to the                 *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifndef __LIBT2N_CLIENT_WRAPPER
#define __LIBT2N_CLIENT_WRAPPER

#include <functional>

#include <boost/config.hpp>
#include <boost/any.hpp>
#include <boost/bind.hpp>
#include <boost/function.hpp>
#include <boost/preprocessor.hpp>

#include <client.hxx>
#include <command_client.hxx>

#ifndef T2N_SINGLETON_WRAPPER_MAX_ARGS
#define T2N_SINGLETON_WRAPPER_MAX_ARGS 9
#endif

namespace libt2n
{

class ConnectionWrapper
{
    public:

        virtual client_connection* get_connection()=0;

        virtual long long get_command_timeout_usec(void)
        {
            return command_client::command_timeout_usec_default;
        }

        virtual long long get_hello_timeout_usec(void)
        {
            return command_client::hello_timeout_usec_default;
        }

        virtual void handle(command_client* stubBase, boost::function< void() > f)
        {
            f();
        }

        virtual ~ConnectionWrapper()
            { }
};

// contains the internal stuff needed for T2nWrapper
namespace detail
{

    template< typename T >
    struct TypeWrap
    {
        typedef T type;
    };

    template< >
    struct TypeWrap< void >
    {
        typedef int type;
    };

    template< typename R >
    struct Call
    {
        typedef boost::function< R() > FuncType;

        FuncType function;
        R& result;

        Call( FuncType f, R& res ) : function(f), result( res ) {}

        void operator()()
        {
            result= function();
        }
    };

    template< >
    struct Call<void>
    {
        typedef boost::function< void() > FuncType;
        typedef TypeWrap< void >::type ResultType;

        FuncType function;
        ResultType& result;

        Call( FuncType f, ResultType& res ) : function(f), result( res ) {}

        void operator()()
        {
            function();
            result= ResultType();
        }
    };
} // eo namespace detail

class T2nSingletonWrapperMessages
{
    protected:
        static const char* NotInitializedMessage;
};

template< class Client >
class T2nSingletonWrapper : public T2nSingletonWrapperMessages
{
    private:
        std::auto_ptr<Client> Stub;

        static std::auto_ptr<T2nSingletonWrapper> SingletonObject;
        static std::auto_ptr<ConnectionWrapper> WrappedConnection;

        // create a prep-method for each possible number of parameters
#define _GEN_ARG(z,n,d) Arg ## n arg ##n
#define _GEN_PREP(z,n,d) \
        template< typename R  BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n,typename Arg) > \
        static boost::function< R(Client*) > prep \
        ( \
            R(Client::*f)( BOOST_PP_ENUM_PARAMS(n,Arg) ) \
            BOOST_PP_COMMA_IF(n) \
            BOOST_PP_ENUM( n, _GEN_ARG, ~ ) \
        ) \
        { \
            return boost::bind< R > \
                ( \
                    f, _1  BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n,arg) \
                ); \
        } // eo prep

        BOOST_PP_REPEAT( BOOST_PP_ADD(T2N_SINGLETON_WRAPPER_MAX_ARGS,1) , _GEN_PREP, ~ )

#undef _GEN_PREP
#undef _GEN_ARG

        T2nSingletonWrapper()
        {
            if (WrappedConnection.get() == NULL)
                throw std::logic_error(NotInitializedMessage);

            Stub=std::auto_ptr<Client>(new Client(*(WrappedConnection->get_connection()),
                WrappedConnection->get_command_timeout_usec(),
                WrappedConnection->get_hello_timeout_usec()));
        }

        template< typename R >
        static
        typename detail::TypeWrap<R>::type real_exec( boost::function< R(Client*) > f)
        {
            ensure_singleton_there();

            typename detail::TypeWrap<R>::type result;
            detail::Call<R> call( boost::bind( f, SingletonObject->Stub.get()), result );
            WrappedConnection->handle(SingletonObject->Stub.get(),call);
            return result;
        }

    public:

        static void set_connection(std::auto_ptr<ConnectionWrapper> wrappedConnection)
        {
            WrappedConnection=wrappedConnection;

            // reset the singleton to NULL because the singleton must be constructed with current WrappedConnection
            if (SingletonObject.get() != NULL)
                SingletonObject.reset();
        }
        static ConnectionWrapper* get_connection(void)
            { return WrappedConnection.get(); }

        static void ensure_singleton_there(void)
        {
            if (SingletonObject.get() == NULL)
                SingletonObject=std::auto_ptr<T2nSingletonWrapper>(new T2nSingletonWrapper());
        }

        // create an exec-method for each possible number of parameters
#define _GEN_PLACEHOLDER(z,n,d) BOOST_PP_CAT(_,BOOST_PP_ADD(n,1))
#define _GEN_EXEC(z,n,d) \
        template< typename R  BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n,typename Arg) > \
        static boost::function< R( BOOST_PP_ENUM_PARAMS(n,Arg) ) > exec \
        ( \
            R(Client::*f)( BOOST_PP_ENUM_PARAMS(n,Arg) ) \
        ) \
        { \
            boost::function<R(Client*)>(*p)(R(Client::*)( BOOST_PP_ENUM_PARAMS(n,Arg) ) \
                    BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n,Arg)) \
                = &T2nSingletonWrapper::template prep<R BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n,Arg) >; \
            return boost::bind \
            ( \
                T2nSingletonWrapper::template real_exec<R>, \
                boost::bind( p, f BOOST_PP_COMMA_IF(n) \
                BOOST_PP_ENUM(n, _GEN_PLACEHOLDER, ~ ) ) \
            ); \
        } // eo exec

        BOOST_PP_REPEAT( BOOST_PP_ADD(T2N_SINGLETON_WRAPPER_MAX_ARGS,1), _GEN_EXEC, ~ )

#undef _GEN_EXEC
#undef _GEN_PLACEHOLDER

};

// create an t2n_exec-method for each possible number of parameters
#define _GEN_EXEC(z,n,d) \
        template< class Client, typename R  BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n,typename Arg) > \
        static boost::function< R( BOOST_PP_ENUM_PARAMS(n,Arg) ) > t2n_exec \
        ( \
            R(Client::*f)( BOOST_PP_ENUM_PARAMS(n,Arg) ) \
        ) \
        { \
            return T2nSingletonWrapper<Client>::exec(f); \
        } // eo exec

        BOOST_PP_REPEAT( BOOST_PP_ADD(T2N_SINGLETON_WRAPPER_MAX_ARGS,1), _GEN_EXEC, ~ )

#undef _GEN_EXEC
#undef _GEN_PLACEHOLDER

}
#endif
Commit	Line	Data
	1	/***************************************************************************
	2	* Copyright (C) 2008 by Gerd v. Egidy and Reinhard Pfau *
	3	* gve@intra2net.com *
	4	* *
	5	* This library is free software; you can redistribute it and/or modify *
	6	* it under the terms of the GNU Lesser General Public License version *
	7	* 2.1 as published by the Free Software Foundation. *
	8	* *
	9	* This library is distributed in the hope that it will be useful, *
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
	12	* GNU Lesser General Public License for more details. *
	13	* *
	14	* You should have received a copy of the GNU Lesser General Public *
	15	* License along with this program; if not, write to the *
	16	* Free Software Foundation, Inc., *
	17	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
	18	***************************************************************************/
	19	#ifndef __LIBT2N_CLIENT_WRAPPER
	20	#define __LIBT2N_CLIENT_WRAPPER
	21
	22	#include <functional>
	23
	24	#include <boost/config.hpp>
	25	#include <boost/any.hpp>
	26	#include <boost/bind.hpp>
	27	#include <boost/function.hpp>
	28	#include <boost/preprocessor.hpp>
	29
	30	#include <client.hxx>
	31	#include <command_client.hxx>
	32
	33	#ifndef T2N_SINGLETON_WRAPPER_MAX_ARGS
	34	#define T2N_SINGLETON_WRAPPER_MAX_ARGS 9
	35	#endif
	36
	37	namespace libt2n
	38	{
	39
	40	class ConnectionWrapper
	41	{
	42	public:
	43
	44	virtual client_connection* get_connection()=0;
	45
	46	virtual long long get_command_timeout_usec(void)
	47	{
	48	return command_client::command_timeout_usec_default;
	49	}
	50
	51	virtual long long get_hello_timeout_usec(void)
	52	{
	53	return command_client::hello_timeout_usec_default;
	54	}
	55
	56	virtual void handle(command_client* stubBase, boost::function< void() > f)
	57	{
	58	f();
	59	}
	60
	61	virtual ~ConnectionWrapper()
	62	{ }
	63	};
	64
	65	// contains the internal stuff needed for T2nWrapper
	66	namespace detail
	67	{
	68
	69	template< typename T >
	70	struct TypeWrap
	71	{
	72	typedef T type;
	73	};
	74
	75	template< >
	76	struct TypeWrap< void >
	77	{
	78	typedef int type;
	79	};
	80
	81	template< typename R >
	82	struct Call
	83	{
	84	typedef boost::function< R() > FuncType;
	85
	86	FuncType function;
	87	R& result;
	88
	89	Call( FuncType f, R& res ) : function(f), result( res ) {}
	90
	91	void operator()()
	92	{
	93	result= function();
	94	}
	95	};
	96
	97	template< >
	98	struct Call<void>
	99	{
	100	typedef boost::function< void() > FuncType;
	101	typedef TypeWrap< void >::type ResultType;
	102
	103	FuncType function;
	104	ResultType& result;
	105
	106	Call( FuncType f, ResultType& res ) : function(f), result( res ) {}
	107
	108	void operator()()
	109	{
	110	function();
	111	result= ResultType();
	112	}
	113	};
	114	} // eo namespace detail
	115
	116	class T2nSingletonWrapperMessages
	117	{
	118	protected:
	119	static const char* NotInitializedMessage;
	120	};
	121
	122	template< class Client >
	123	class T2nSingletonWrapper : public T2nSingletonWrapperMessages
	124	{
	125	private:
	126	std::auto_ptr<Client> Stub;
	127
	128	static std::auto_ptr<T2nSingletonWrapper> SingletonObject;
	129	static std::auto_ptr<ConnectionWrapper> WrappedConnection;
	130
	131	// create a prep-method for each possible number of parameters
	132	#define _GEN_ARG(z,n,d) Arg ## n arg ##n
	133	#define _GEN_PREP(z,n,d) \
	134	template< typename R BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n,typename Arg) > \
	135	static boost::function< R(Client*) > prep \
	136	( \
	137	R(Client::*f)( BOOST_PP_ENUM_PARAMS(n,Arg) ) \
	138	BOOST_PP_COMMA_IF(n) \
	139	BOOST_PP_ENUM( n, _GEN_ARG, ~ ) \
	140	) \
	141	{ \
	142	return boost::bind< R > \
	143	( \
	144	f, _1 BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n,arg) \
	145	); \
	146	} // eo prep
	147
	148	BOOST_PP_REPEAT( BOOST_PP_ADD(T2N_SINGLETON_WRAPPER_MAX_ARGS,1) , _GEN_PREP, ~ )
	149
	150	#undef _GEN_PREP
	151	#undef _GEN_ARG
	152
	153	T2nSingletonWrapper()
	154	{
	155	if (WrappedConnection.get() == NULL)
	156	throw std::logic_error(NotInitializedMessage);
	157
	158	Stub=std::auto_ptr<Client>(new Client(*(WrappedConnection->get_connection()),
	159	WrappedConnection->get_command_timeout_usec(),
	160	WrappedConnection->get_hello_timeout_usec()));
	161	}
	162
	163	template< typename R >
	164	static
	165	typename detail::TypeWrap<R>::type real_exec( boost::function< R(Client*) > f)
	166	{
	167	ensure_singleton_there();
	168
	169	typename detail::TypeWrap<R>::type result;
	170	detail::Call<R> call( boost::bind( f, SingletonObject->Stub.get()), result );
	171	WrappedConnection->handle(SingletonObject->Stub.get(),call);
	172	return result;
	173	}
	174
	175	public:
	176
	177	static void set_connection(std::auto_ptr<ConnectionWrapper> wrappedConnection)
	178	{
	179	WrappedConnection=wrappedConnection;
	180
	181	// reset the singleton to NULL because the singleton must be constructed with current WrappedConnection
	182	if (SingletonObject.get() != NULL)
	183	SingletonObject.reset();
	184	}
	185	static ConnectionWrapper* get_connection(void)
	186	{ return WrappedConnection.get(); }
	187
	188	static void ensure_singleton_there(void)
	189	{
	190	if (SingletonObject.get() == NULL)
	191	SingletonObject=std::auto_ptr<T2nSingletonWrapper>(new T2nSingletonWrapper());
	192	}
	193
	194	// create an exec-method for each possible number of parameters
	195	#define _GEN_PLACEHOLDER(z,n,d) BOOST_PP_CAT(_,BOOST_PP_ADD(n,1))
	196	#define _GEN_EXEC(z,n,d) \
	197	template< typename R BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n,typename Arg) > \
	198	static boost::function< R( BOOST_PP_ENUM_PARAMS(n,Arg) ) > exec \
	199	( \
	200	R(Client::*f)( BOOST_PP_ENUM_PARAMS(n,Arg) ) \
	201	) \
	202	{ \
	203	boost::function<R(Client)>(p)(R(Client::*)( BOOST_PP_ENUM_PARAMS(n,Arg) ) \
	204	BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n,Arg)) \
	205	= &T2nSingletonWrapper::template prep<R BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n,Arg) >; \
	206	return boost::bind \
	207	( \
	208	T2nSingletonWrapper::template real_exec<R>, \
	209	boost::bind( p, f BOOST_PP_COMMA_IF(n) \
	210	BOOST_PP_ENUM(n, _GEN_PLACEHOLDER, ~ ) ) \
	211	); \
	212	} // eo exec
	213
	214	BOOST_PP_REPEAT( BOOST_PP_ADD(T2N_SINGLETON_WRAPPER_MAX_ARGS,1), _GEN_EXEC, ~ )
	215
	216	#undef _GEN_EXEC
	217	#undef _GEN_PLACEHOLDER
	218
	219	};
	220
	221	// create an t2n_exec-method for each possible number of parameters
	222	#define _GEN_EXEC(z,n,d) \
	223	template< class Client, typename R BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n,typename Arg) > \
	224	static boost::function< R( BOOST_PP_ENUM_PARAMS(n,Arg) ) > t2n_exec \
	225	( \
	226	R(Client::*f)( BOOST_PP_ENUM_PARAMS(n,Arg) ) \
	227	) \
	228	{ \
	229	return T2nSingletonWrapper<Client>::exec(f); \
	230	} // eo exec
	231
	232	BOOST_PP_REPEAT( BOOST_PP_ADD(T2N_SINGLETON_WRAPPER_MAX_ARGS,1), _GEN_EXEC, ~ )
	233
	234	#undef _GEN_EXEC
	235	#undef _GEN_PLACEHOLDER
	236
	237	}
	238	#endif