ReflectorInterface.h File Reference

Contains the base interface of all Reflectors, Serializers, etc. More...

#include <string>
#include <unordered_map>
#include <boost/preprocessor/repetition.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <platform/Environment.h>
#include <platform/Typename.h>
#include <rpc/RPCMacros.h>
#include <serialization/GetterSetter.h>
#include <serialization/PropertyHint.h>
#include <serialization/ReflectControlFlags.h>

Include dependency graph for ReflectorInterface.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	AcceptDesiredVersion
	Tag class used as parameter to ReflectorInterface::version() etc. More...
class	ReflectorInterface< Derived >
	This is the public interface of all reflectors that are able to visit a class' reflect() method. More...
struct	ReflectorInterface< Derived >::Tag
struct	ReflectorInterface< Derived >::ReflectState
	If 'reflect barriers' are used, each separated reflection block within an object has a separate state (defined by the Reflector). More...

Namespaces
	mira
	specialize cv::DataType for our ImgPixel and inherit from cv::DataType<Vec>
	mira::serialization

Macros
#define	MIRA_REFLECT_VERSION(reflector, versionNumber)   reflector.version(versionNumber, this)
	Macro that should be used to specify the (reflected) version of the class. More...
#define	MIRA_REFLECT_REQUIRE_VERSION(reflector, versionNumber)   reflector.requireVersion(versionNumber, this)
	Macro that should be used to specify the required (reflected) version of the class. More...
#define	MIRA_REFLECT_BASE(reflector, BaseClass)   reflector.template reflectBase<BaseClass>(*this)
	Macro that can be used to reflect the base class easily. More...
#define	MIRA_REFLECT_BASE_NONINTRUSIVE(reflector, BaseClass, object)   reflector.template reflectBase<BaseClass>(object)
	Macro that can be used to reflect the base class easily in a non-intrusive reflect() method. More...
#define	MIRA_REFLECT_BASE_IF_VERSION_ATLEAST(reflector, BaseClass, versionvar, minversion)
	Macro that can be used to selectively call BaseClass::reflect() directly or through reflectBase(), depending on version. More...
#define	MIRA_REFLECT_BASE_NONINTRUSIVE_IF_VERSION_ATLEAST(reflector, BaseClass, object, versionvar, minversion)
	Macro that can be used in non-intrusive reflection to selectively call reflect(reflector, (BaseClass&)object) directly or through reflectBase(), depending on version. More...
#define	MIRA_MEMBER_WITH_ID(reflector, name, id, var,...)
	Macro that should be used to reflect a member if a manually specified ID is used. More...
#define	MIRA_PROPERTY_WITH_ID(reflector, name, id, var,...)
Methods for reflecting RPC (remote procedure call) methods
#define	RPC_METHODS_MAX_PARAMS   8
#define	RPCGEN_METHODS(z, n, _)
#define	RPCGEN_METHODS_PARAMDESC(z, n, _)
#define	RPCGEN_METHODS_PARAMDESCSAMPLE(z, n, _)
#define	RPCGEN_METHODS_WRONG_ARGUMENT_NUMBER(z, n, _)
#define	RPCGEN_METHODS_INVALID(z, n, _)

Typedefs
typedef uint8	VersionType
typedef std::unordered_map < Typename, VersionType >	ClassVersionMap

Detailed Description

Contains the base interface of all Reflectors, Serializers, etc.

Author

Erik Einhorn

Date

2010/09/22

Macro Definition Documentation

#define RPC_METHODS_MAX_PARAMS   8

#define RPCGEN_METHODS	(		z,
			n,
			_
	)

Value:

template<typename R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P)>                                 \
    void method(const char* name, R (*fn)(BOOST_PP_ENUM_PARAMS_Z(z,n,P)), const char* comment) {}        \
                                                                                                         \
    template<typename R, typename Class BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P)>                 \
    void method(const char* name, R (Class::*fn)(BOOST_PP_ENUM_PARAMS_Z(z,n,P)), Class*, const char* comment) {} \
                                                                                                         \
    template<typename R, typename Class BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P)>                 \
    void method(const char* name, R (Class::*fn)(BOOST_PP_ENUM_PARAMS_Z(z,n,P)) const, Class*, const char* comment) {} \
                                                                                                         \
    template<typename R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P)>                                 \
    void method(const char* name, boost::function<R (BOOST_PP_ENUM_PARAMS_Z(z,n,P))>, const char* comment) {} \

#define RPCGEN_METHODS_PARAMDESC	(		z,
			n,
			_
	)

Value:

template<typename R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P)>                                 \
    void method(const char* name, R (*fn)(BOOST_PP_ENUM_PARAMS_Z(z,n,P)),                                \
                const char* comment, BOOST_PP_ENUM(n,RPCGEN_CALL_NAME_DESC_DECL,nil)) {}                 \
                                                                                                         \
    template<typename R, typename Class BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P)>                 \
    void method(const char* name, R (Class::*fn)(BOOST_PP_ENUM_PARAMS_Z(z,n,P)), Class*,                 \
                const char* comment, BOOST_PP_ENUM(n,RPCGEN_CALL_NAME_DESC_DECL,nil)) {}                 \
                                                                                                         \
    template<typename R, typename Class BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P)>                 \
    void method(const char* name, R (Class::*fn)(BOOST_PP_ENUM_PARAMS_Z(z,n,P)) const, Class*,           \
                const char* comment, BOOST_PP_ENUM(n,RPCGEN_CALL_NAME_DESC_DECL,nil)) {}                 \
                                                                                                         \
    template<typename R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P)>                                 \
    void method(const char* name, boost::function<R (BOOST_PP_ENUM_PARAMS_Z(z,n,P))>,                    \
                const char* comment, BOOST_PP_ENUM(n,RPCGEN_CALL_NAME_DESC_DECL,nil)) {}                 \

#define RPCGEN_METHODS_PARAMDESCSAMPLE	(		z,
			n,
			_
	)

Value:

template<typename R, BOOST_PP_ENUM(n,RPCGEN_CALL_TYPENAME_PARAM_DECL,nil)>                           \
    void method(const char* name, R (*fn)(BOOST_PP_ENUM_PARAMS_Z(z,n,P)),                                \
                const char* comment, BOOST_PP_ENUM(n,RPCGEN_CALL_NAME_DESC_SAMPLE_DECL,nil)) {}          \
                                                                                                         \
    template<typename R, typename Class, BOOST_PP_ENUM(n,RPCGEN_CALL_TYPENAME_PARAM_DECL,nil)>           \
    void method(const char* name, R (Class::*fn)(BOOST_PP_ENUM_PARAMS_Z(z,n,P)), Class*,                 \
                const char* comment, BOOST_PP_ENUM(n,RPCGEN_CALL_NAME_DESC_SAMPLE_DECL,nil)) {}          \
                                                                                                         \
    template<typename R, typename Class, BOOST_PP_ENUM(n,RPCGEN_CALL_TYPENAME_PARAM_DECL,nil)>           \
    void method(const char* name, R (Class::*fn)(BOOST_PP_ENUM_PARAMS_Z(z,n,P)) const, Class*,           \
                const char* comment, BOOST_PP_ENUM(n,RPCGEN_CALL_NAME_DESC_SAMPLE_DECL,nil)) {}          \
                                                                                                         \
    template<typename R, BOOST_PP_ENUM(n,RPCGEN_CALL_TYPENAME_PARAM_DECL,nil)>                           \
    void method(const char* name, boost::function<R (BOOST_PP_ENUM_PARAMS_Z(z,n,P))>,                    \
                const char* comment, BOOST_PP_ENUM(n,RPCGEN_CALL_NAME_DESC_SAMPLE_DECL,nil)) {}          \

#define RPCGEN_METHODS_WRONG_ARGUMENT_NUMBER	(		z,
			n,
			_
	)

Value:

template<typename R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P), typename... Args>               \
    void method(const char* name, R (*fn)(BOOST_PP_ENUM_PARAMS_Z(z,n,P)),                                \
                const char* comment, Args...) {}                                                         \
                                                                                                         \
    template<typename R, typename Class BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P), typename... Args> \
    void method(const char* name, R (Class::*fn)(BOOST_PP_ENUM_PARAMS_Z(z,n,P)), Class* This,            \
                const char* comment, Args...) {}                                                         \
                                                                                                         \
    template<typename R, typename Class BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P), typename... Args> \
    void method(const char* name, R (Class::*fn)(BOOST_PP_ENUM_PARAMS_Z(z,n,P)) const, Class* This,      \
                const char* comment, Args...) {}                                                         \
                                                                                                         \
    template<typename R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P), typename... Args>               \
    void method(const char* name, boost::function<R (BOOST_PP_ENUM_PARAMS_Z(z,n,P))> fn,                 \
                const char* comment, Args...) {}                                                         \

#define RPCGEN_METHODS_INVALID	(		z,
			n,
			_
	)

Value:

template<typename R BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,n,typename P)>                                 \
    void invalid_method()                                                                                \
    {    /* force this to fail whenever it is instantiated - but only then! */                           \
        static_assert(sizeof(R*)==0,                                                                     \
                      "_____________NUMBER OR TYPES OF NAMES/DESCRIPTIONS/SAMPLEVALUES FOR PARAMETERS "  \
                      "IN CALL TO Reflector::method() DO NOT MATCH THE PROVIDED FUNCTION'S SIGNATURE. "  \
                      "PLEASE PROVIDE const char* NAME AND DESCRIPTION FOR EACH RPC METHOD PARAMETER, "  \
                      "OR NAME, DESCRIPTION AND A CORRECTLY TYPED SAMPLE VALUE FOR EACH PARAMETER._____________"); \
    }

#define MIRA_PROPERTY_WITH_ID	(		reflector,
			name,
			id,
			var,
			...
	)

Value:

if(reflector.usesHumanReadableIDs())                     \
        reflector.property(name, id, var, __VA_ARGS__);      \
    else                                                     \
        reflector.property(name, var, __VA_ARGS__);