#include <serialization/MetaSerializer.h>

Inheritance diagram for MetaSerializer:

[legend]

Classes
struct	TypeWithoutObjectAbstractHelper

struct	TypeWithoutObjectAbstractHelper< T *, true >

struct	TypeWithoutObjectAbstractHelper< T, true >

struct	TypeWithoutObjectHelper

struct	TypeWithoutObjectHelper< T *, true >

struct	TypeWithoutObjectHelper< T, true >

Public Types
typedef boost::mpl::bool_< false >	isObjectTrackingSupported

typedef boost::mpl::bool_< true >	requireReflectBarriers

typedef CompoundMeta::Member *	ReflectState

typedef serialization::VersionType	VersionType

typedef BinarySerializerTag	Tag

typedef serialization::AcceptDesiredVersion	AcceptDesiredVersion

typedef boost::mpl::bool_< true >	isReadOnly

typedef Base::ClassVersionMap	ClassVersionMap

typedef boost::mpl::bool_< true >	useHumanReadableIDs
	Specifies, if the Reflector supports human readable IDs. More...

Public Member Functions
	MetaSerializer (MetaTypeDatabase &database)
	The meta serializer will work on the database and adds new types there. More...

template<typename T >
TypeMetaPtr	addMeta (const T &v)

template<typename T >
VersionType	version (VersionType version, const T *caller=NULL)

	MIRA_DEPRECATED ("Please call as version<MyType>(v) or version(v, this)", VersionType version(VersionType version))

template<typename T >
VersionType	version (VersionType version, AcceptDesiredVersion, const T *caller=NULL)

ReflectState	preReflect (const char *context="")

void	postReflect (const ReflectState &prev)

template<typename T >
void	write (const T *data, std::size_t count)

template<typename T >
bool	hasCodec () const
	Returns true, of there is a codec for the specified type T. More...

template<typename T >
bool	codec (const T &obj)
	Encodes the specified object containing the data using a matching codec. More...

void	interface (const char *name)

void	addMethod (MethodMetaPtr method)

template<typename R , typename... Args, typename F , typename... Description>
InvalidRPCDescription< R(Args...), Description... >	method (const char *, F &&, Description &&...)

template<typename F , typename... Description>
InvalidRPCDescription< F, Description... >	method (const char *, F &&, Description &&...)

template<typename R , typename Class , typename... Args, typename... Description>
InvalidRPCDescription< R(Class::*)(Args...), Description... >	method (const char , R(Class::)(Args...), Class *, Description &&...)

template<typename R , typename Class , typename... Args, typename... Description>
InvalidRPCDescription< R(Class::*)(Args...) const, Description... >	method (const char , R(Class::)(Args...) const, Class *, Description &&...)

template<typename R , typename... Args, typename F , typename... Description>
ValidRPCDescription< R(Args...), Description... >	method (const char *name, F &&fn, Description &&... descriptions)

template<typename F , typename... Description>
ValidRPCDescription< F, Description... >	method (const char *name, F &&fn, Description &&... descriptions)

template<typename R , typename Class , typename... Args, typename... Description>
ValidRPCDescription< R(Class::*)(Args...), Description... >	method (const char name, R(Class::fn)(Args...), Class *This, Description &&... descriptions)

template<typename R , typename Class , typename... Args, typename... Description>
ValidRPCDescription< R(Class::*)(Args...) const, Description... >	method (const char name, R(Class::fn)(Args...) const, Class *This, Description &&... descriptions)

template<typename T >
void	atomic (T &)

template<typename T >
void	enumeration (T &)

template<typename T >
void	pointer (T *&pointer)

template<typename T >
void	object (T &member)

template<typename T >
void	invokeOverwrite (T &object)

template<typename T >
void	invokeOverwrite (serialization::PlainArray< T > &array)
	Specialized for PlainArray, because the BinarySerializer does it... More...

template<typename T >
void	property (const char name, T &member, const char comment, PropertyHint &&hint=PropertyHint(), ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)

template<typename T >
void	property (const char name, const std::string &id, T &member, const char comment, PropertyHint &&hint=PropertyHint(), ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)

template<typename T >
void	property (const char name, const T &member, Setter< T > setter, const char comment, PropertyHint &&hint=PropertyHint(), ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)

template<typename T >
void	property (const char name, Getter< T > getter, Setter< T > setter, const char comment, PropertyHint &&hint=PropertyHint(), ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)

template<typename T , typename U >
void	property (const char name, T &member, const char comment, const U &defaultValue, PropertyHint &&hint=PropertyHint(), ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)

template<typename T , typename U >
void	property (const char name, const T &member, Setter< T > setter, const char comment, const U &defaultValue, PropertyHint &&hint=PropertyHint(), ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)

template<typename T , typename U >
void	property (const char name, Getter< T > getter, Setter< T > setter, const char comment, const U &defaultValue, PropertyHint &&hint=PropertyHint(), ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)

template<typename T >
void	delegate (T &member, ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)

template<typename T >
void	delegate (const T &member, Setter< T > setter, ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)

template<typename T >
void	delegate (Getter< T > getter, Setter< T > setter, ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)

template<typename T >
void	collectionItems (const std::string &countName, bool blockdump=false)

VersionType	version (VersionType version, const T *caller=NULL)

VersionType	version (VersionType version, AcceptDesiredVersion, const T *caller=NULL)

	MIRA_DEPRECATED ("Please call as requireVersion<MyType>(v, minV) or requireVersion(v, minV, this)", VersionType requireVersion(VersionType version, VersionType minVersion))

	MIRA_DEPRECATED ("Please call as requireVersion<MyType>(v) or requireVersion(v, this)", void requireVersion(VersionType requiredVersion))

void	desireClassVersions (const ClassVersionMap &versions)
	implements ReflectorInterface (for documentation see ReflectorInterface) More...

void	serialize (const std::string &name, const T &value, const std::string &comment="")
	Serializes the specified object value under the given name. More...

void	trackObject (T &member)

void	pointerNormal (T *&pointer, int typeId)

void	pointerPolymorphic (T *&pointer, int typeId)

void	pointerAbstract (T *&pointer, int typeId)

void	pushObjectTrackingStore ()

void	popObjectTrackingStore ()

void	member (const char name, T &member, const char comment, ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)

void	member (const char name, const std::string &id, T &member, const char comment, ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)

void	member (const char name, const T &member, Setter< T > setter, const char comment, ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)

void	member (const char name, Getter< T > getter, Setter< T > setter, const char comment, ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)

void	member (const char name, T &member, const char comment, const T &defaultValue, ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)

void	member (const char name, T &member, const char comment, const U &defaultValue, ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)

void	member (const char name, const T &member, Setter< T > setter, const char comment, const T &defaultValue, ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)

void	member (const char name, const T &member, Setter< T > setter, const char comment, const U &defaultValue, ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)

void	member (const char name, Getter< T > getter, Setter< T > setter, const char comment, const T &defaultValue, ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)

void	member (const char name, Getter< T > getter, Setter< T > setter, const char comment, const U &defaultValue, ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)

void	property (const char name, T &member, const char comment, const T &defaultValue, PropertyHint &&hint=PropertyHint(), ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)

void	property (const char name, const T &member, Setter< T > setter, const char comment, const T &defaultValue, PropertyHint &&hint=PropertyHint(), ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)

void	property (const char name, Getter< T > getter, Setter< T > setter, const char comment, const T &defaultValue, PropertyHint &&hint=PropertyHint(), ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)

const ReflectMemberMeta &	getCurrentMemberMeta () const
	Returns the meta-information of the current member that is reflected. More...

const std::string &	getCurrentMemberFullID () const
	Returns the full human readable object id / name of the current member being reflected. More...

void	invokeMember (T &member, const ReflectMemberMeta &meta)
	Is called to invoke this Reflector on the member with the specified meta information. More...

void	invokeMemberOverwrite (T &member, const ReflectMemberMeta &meta)
	The actual invokeMember implementation that is called from invokeMember(). More...

void	invokePointerObject (T &member)
	Is called to reflect objects of pointers. More...

void	invokeMemberWithoutDefault (T &member, const ReflectMemberMeta &meta)
	Delegates to invokeMember() and rethrows any occurring XMemberNotFound exception as XIO exception. More...

void	invokeMemberWithDefault (T &member, const ReflectMemberMeta &meta, const U &defaultValue)
	Delegates to invokeMember() and handles any occurring XMemberNotFound exception by setting the member to the given default value. More...

void	invokeMemberWithDefault (T &member, const ReflectMemberMeta &meta, const serialization::IgnoreMissing &defaultValue)
	Delegates to invokeMember() and handles any occurring XMemberNotFound exception by ignoring the exception and hence the missing member, as indicated by IgnoreMissing as default value. More...

VersionType	requireVersion (VersionType version, VersionType minVersion, const T *caller=NULL)
	implements ReflectorInterface (for documentation see ReflectorInterface) More...

void	requireVersion (VersionType requiredVersion, const T *caller=NULL)
	implements ReflectorInterface (for documentation see ReflectorInterface) More...

VersionType	requireVersion (VersionType version, VersionType minVersion, AcceptDesiredVersion, const T *caller=NULL)
	implements ReflectorInterface (for documentation see ReflectorInterface) More...

void	requireVersion (VersionType requiredVersion, AcceptDesiredVersion, const T *caller=NULL)
	implements ReflectorInterface (for documentation see ReflectorInterface) More...

void	reflectBase (Base &base)
	implements ReflectorInterface (for documentation see ReflectorInterface) More...

void	postReflect (const ReflectState &)
	See preReflect for documentation. More...

Optional Class Versioning.
These visiting methods may be supported by different reflectors like the RecursiveMemberReflector and the RPCMethodReflector, etc. Note Specifying versions for serialized classes is optional. requireVersion() and version() currently are supported by serialization reflectors only.
VersionType	version (VersionType version, AcceptDesiredVersion, const T *caller=NULL)
	Extension of version() (see above), that additionally signals the reflector that the caller will properly handle a different version than the one it specifies itself. More...

	MIRA_DEPRECATED ("Please call as requireVersion<MyType>(v, minV) or requireVersion(v, minV, this)", VersionType requireVersion(VersionType version, VersionType minVersion))
	Deprecated 'anonymous' (no type) requireVersion(). More...

	MIRA_DEPRECATED ("Please call as requireVersion<MyType>(v) or requireVersion(v, this)", VersionType requireVersion(VersionType version))
	Deprecated 'anonymous' (no type) requireVersion(). More...

VersionType	requireVersion (VersionType version, VersionType minVersion, const T *caller=NULL)
	Same as above, but allows to specify a minimum supported version, and throws XIO if the minimum version requirement is not met. More...

void	requireVersion (VersionType version, const T *caller=NULL)
	Specifies the current class version, which is also the minimum (and therefore only) version accepted (therefore, no need to return a version number). More...

VersionType	requireVersion (VersionType version, VersionType minVersion, AcceptDesiredVersion, const T *caller=NULL)
	Extension of requireVersion() (see above), that additionally signals the reflector that the caller will properly handle a different version than the one it specifies itself. More...

void	requireVersion (VersionType version, AcceptDesiredVersion, const T *caller=NULL)
	Extension of requireVersion() (see above), that additionally signals the reflector that the caller will properly handle a different version than it one it specifies itself. More...

Special Pointer Handlers For Overwriting
void	pointerReference (int referencedObjectID)
	Is called by the pointer() method if an object, a pointer references, was already serialized and a reference to that object must be stored instead of the whole object. More...

void	pointerNull ()
	Is called by the pointer() method to indicate that a pointer that is to be serialized is a NULL-pointer. More...

void	pointerWithoutClassType ()
	Is called if a pointer points to a non-polymorphic type and hence the object can be stored without specifying a class type. More...

void	pointerWithClassType (const std::string &type)
	Is called if a pointer points to a polymorphic type and hence the object must be stored with specifying a class type. More...

Visiting methods that are called by the RecursiveMemberReflector
while reflecting the members
void	collection (T &member)
	Is called for each complex object or array, where the IsCollection<T> trait is true_type. More...

Methods for reflecting members
These visiting methods are supported by the RecursiveMemberReflector.
void	roproperty (const char name, const T &member, const char comment, PropertyHint &&hint=PropertyHint(), ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)
	A property that just reflects a runtime state of the object and can be displayed but not altered. More...

void	roproperty (const char name, const std::string &id, const T &member, const char comment, PropertyHint &&hint=PropertyHint(), ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)
	Same as above, with an extra parameter for specifying the id explicitly if it differs from name. More...

void	roproperty (const char name, Getter< T > getter, const char comment, PropertyHint &&hint=PropertyHint(), ReflectCtrlFlags flags=REFLECT_CTRLFLAG_NONE)
	Same as above, with a special getter method for reading the member. More...

void	itemName (const std::string &name)
	If the currently reflected object is an item within a collection, this allows to specify an explicit name for that item. More...

Methods for reflecting RPC (remote procedure call) methods
void	method (const char name, Method method, const char comment, const char paramName, const char paramDescription, P paramSampleValue,...)
	Specifies that the class that is reflected provides a service through the specified static member function or free function. More...

void	method (const char name, Method method, Class object, const char comment, const char paramName, const char *paramDescription, P paramSampleValue,...)
	Specifies that the class that is reflected provides a service through the specified non-static member function. More...

void	invalid_method ()

Static Public Member Functions
static int	forcedSerializeVersion ()
	Returns either the version number from value of environment variable 'MIRA_FORCE_SERIALIZE_VERSION', or -1 (= do not force a version). More...

static void	registerClass ()
	Registers a new polymorphic class at the PolymorphPointerReflector. More...

static void	unregisterClass ()
	Unregisters the class. More...

static bool	isReflectedAsPointer ()
	For internal use only: Returns true, if the type T is ever reflected as pointer within the current translation unit (C file). More...

static bool	usesHumanReadableIDs ()
	Returns true, if the concrete derived Reflector supports human readable IDs. More...

Protected Types
typedef std::set< AObject >	ObjectSet

typedef std::map< int, std::string >	ObjectIDToNameMap

typedef std::pair< ObjectSet, ObjectIDToNameMap >	TrackingState

Protected Member Functions
VersionType	version (VersionType version, const std::string &type, bool acceptDesiredVersion=false)

CompoundMetaPtr	createMapEntry (TypeMetaPtr &type)

void	addCurrentAsMemberToParent ()

template<typename T >
TypeMetaPtr	createMeta ()

template<typename T >
TypeMetaPtr	createMetaOrVoidHelper ()

template<typename T >
TypeMetaPtr	createMetaHelper ()

template<typename T >
TypeMetaPtr	createMetaHelper (T *)

TypeMetaPtr	createMetaHelper (void *)

template<typename R , typename... Args, typename... Description>
void	concreteMethodMetaHelper (const char *name, Private::ArgumentTuple< Args... >, Description &&... descriptions)

template<typename R , typename ... Args, typename Comment , typename ... Descriptions>
void	createMethodMeta (const std::string &name, Comment &&comment, Descriptions &&... args)

VersionType	queryDesiredClassVersion (VersionType version, const std::string &type, bool acceptDesiredVersion=false)

VersionType	queryDesiredClassVersion (VersionType version, bool acceptDesiredVersion=false)

bool	isTrackingEnabled () const
	Returns true, if object tracking is enabled for the type T. More...

const std::string &	getHumanReadableFullID (int objectID) const
	Returns the full human readable object id / name for the given internal objectID. More...

void	invokeTrackObject (T &member)
	tracks the given object (if pointer tracking is enabled for type T) More...

void	reflectUnknown (T &member)

void	reflectAtomic (T &member)
	Type A1: for atomic members (float,int,etc.) More...

void	reflectEnumeration (T &member)
	Type A2: for enums. More...

void	reflectArray (T &member)
	Type A3: for arrays. More...

void	reflectComplex (T &member)
	Type B1/B2: for complex types. More...

void	reflectCollection (T &member)
	Type B?c: for collection types. More...

void	reflectPointer (T &member)
	Type C: for members that are pointers. More...

void	reflectPointerNormal (T *&member)
	Type C1: for members that are pointers to normal classes. More...

void	reflectPointerPolymorphic (T *&member)
	Type C2: for members that are pointers to polymorphic classes derived from mira::Object. More...

void	reflectPointerAbstract (T *&member)
	Type C3: for members that are pointers to abstract classes not derived from mira::Object. More...

void	chooseReflect (T &member)
	Detect the members type (A1,A2,A3,B1,B2,C) and choose the appropriate function. More...

MetaSerializer *	This ()
	"Curiously recurring template pattern" (CRTP). More...

void	invoke (T &object)
	Invokes this reflector on the specified object. More...

void	reflectComplexIntrusive (T &object)
	For classes with reflect method call their reflect method directly. More...

void	reflectComplexNonintrusive (T &object)
	For classes without reflect method, where we need to look somewhere else to get the information for visiting it. More...

void	reflectMissing (T &object)

Static Protected Member Functions
static int	checkForcedVersion (const std::string &variable)

Protected Attributes
MetaTypeDatabase &	mMetaDatabase

TypeMetaPtr	mCurrentMeta

CompoundMetaPtr	mParentMeta

CompoundMeta::Member *	mCurrentVersion

ClassVersionMap	mDesiredClassVersions

ObjectSet	mObjects

ObjectIDToNameMap	mObjectIDToName

std::stack< TrackingState >	mTrackingStack

Static Protected Attributes
static constexpr auto	MIRA_REFLECTOR_TOPLEVEL_NAME
	Use this when a reflector needs to choose a name for serializing an object. More...

Friends
template<typename T , bool >
struct	TypeWithoutObjectHelper

template<typename T , bool >
struct	TypeWithoutObjectAbstractHelper

Member Typedef Documentation

◆ isObjectTrackingSupported

typedef boost::mpl::bool_<false> isObjectTrackingSupported

◆ requireReflectBarriers

typedef boost::mpl::bool_<true> requireReflectBarriers

◆ ReflectState

typedef CompoundMeta::Member* ReflectState

◆ VersionType

typedef serialization::VersionType VersionType

◆ Tag

typedef BinarySerializerTag Tag

inherited

◆ AcceptDesiredVersion

typedef serialization::AcceptDesiredVersion AcceptDesiredVersion

inherited

◆ isReadOnly

typedef boost::mpl::bool_<true> isReadOnly

inherited

◆ ClassVersionMap

typedef Base::ClassVersionMap ClassVersionMap

inherited

◆ ObjectSet

typedef std::set<AObject> ObjectSet

protectedinherited

◆ ObjectIDToNameMap

typedef std::map<int, std::string> ObjectIDToNameMap

protectedinherited

◆ TrackingState

typedef std::pair<ObjectSet, ObjectIDToNameMap> TrackingState

protectedinherited

◆ useHumanReadableIDs

typedef boost::mpl::bool_<true> useHumanReadableIDs

inherited

Specifies, if the Reflector supports human readable IDs.

This type must be set to the proper boost::mpl::bool type by the derived Reflector class. (Default is true)

Constructor & Destructor Documentation

◆ MetaSerializer()

MetaSerializer ( MetaTypeDatabase & database )

inline

The meta serializer will work on the database and adds new types there.

Member Function Documentation

◆ addMeta()

TypeMetaPtr addMeta ( const T & v )

inline

◆ version() [1/6]

VersionType version	(	VersionType	version,
		const std::string &	type,
		bool	acceptDesiredVersion = `false`
	)

inlineprotected

◆ version() [2/6]

VersionType version	(	VersionType	version,
		const T *	caller = `NULL`
	)

inline

◆ MIRA_DEPRECATED() [1/5]

MIRA_DEPRECATED	(	"Please call as version<MyType>(v) or version(v, this)"	,
		VersionType	versionVersionType version
	)

inline

◆ version() [3/6]

VersionType version	(	VersionType	version,
		AcceptDesiredVersion	,
		const T *	caller = `NULL`
	)

inline

◆ preReflect()

ReflectState preReflect ( const char * context = "" )

inline

◆ postReflect() [1/2]

void postReflect ( const ReflectState & prev )

inline

◆ write()

void write	(	const T *	data,
		std::size_t	count
	)

inline

◆ hasCodec()

bool hasCodec ( ) const

inline

Returns true, of there is a codec for the specified type T.

In this case, the encode method can be used to encode the data using the codec.

◆ codec()

bool codec ( const T & obj )

inline

Encodes the specified object containing the data using a matching codec.

The encoded data will be written directly into the binary output. If no codec was found, false is returned, and the caller must serialize the data manually without codec (in this case "NULL" is written as codec fourcc into the binary stream).

◆ interface()

void interface ( const char * name )

inline

◆ addMethod()

void addMethod ( MethodMetaPtr method )

inline

◆ method() [1/10]

InvalidRPCDescription<R(Args...), Description...> method	(	const char *	,
		F &&	,
		Description &&	...
	)

inline

◆ method() [2/10]

InvalidRPCDescription<F, Description...> method	(	const char *	,
		F &&	,
		Description &&	...
	)

inline

◆ method() [3/10]

InvalidRPCDescription<R (Class::*)(Args...), Description...> method	(	const char *	,
		R(Class::*)(Args...)	,
		Class *	,
		Description &&	...
	)

inline

◆ method() [4/10]

InvalidRPCDescription<R (Class::*)(Args...) const, Description...> method	(	const char *	,
		R(Class::*)(Args...)	const,
		Class *	,
		Description &&	...
	)

inline

◆ method() [5/10]

ValidRPCDescription<R(Args...), Description...> method	(	const char *	name,
		F &&	fn,
		Description &&...	descriptions
	)

inline

◆ method() [6/10]

ValidRPCDescription<F, Description...> method	(	const char *	name,
		F &&	fn,
		Description &&...	descriptions
	)

inline

◆ method() [7/10]

ValidRPCDescription<R (Class::*)(Args...), Description...> method	(	const char *	name,
		R(Class::*)(Args...)	fn,
		Class *	This,
		Description &&...	descriptions
	)

inline

◆ method() [8/10]

ValidRPCDescription<R (Class::*)(Args...) const, Description...> method	(	const char *	name,
		R(Class::*)(Args...) const	fn,
		Class *	This,
		Description &&...	descriptions
	)

inline

◆ atomic()

void atomic ( T & )

inline

◆ enumeration()

void enumeration ( T & )

inline

◆ pointer()

void pointer ( T *& pointer )

inline

◆ object()

void object ( T & member )

inline

◆ invokeOverwrite() [1/2]

void invokeOverwrite ( T & object )

inline

◆ invokeOverwrite() [2/2]

void invokeOverwrite ( serialization::PlainArray< T > & array )

inline

Specialized for PlainArray, because the BinarySerializer does it...

◆ createMapEntry()

CompoundMetaPtr createMapEntry ( TypeMetaPtr & type )

inlineprotected

◆ addCurrentAsMemberToParent()

void addCurrentAsMemberToParent ( )

inlineprotected

◆ createMeta()

TypeMetaPtr createMeta ( )

inlineprotected

◆ createMetaOrVoidHelper()

TypeMetaPtr createMetaOrVoidHelper ( )

inlineprotected

◆ createMetaHelper() [1/3]

TypeMetaPtr createMetaHelper ( )

inlineprotected

◆ createMetaHelper() [2/3]

TypeMetaPtr createMetaHelper ( T * )

inlineprotected

◆ createMetaHelper() [3/3]

TypeMetaPtr createMetaHelper ( void * )

inlineprotected

◆ concreteMethodMetaHelper()

void concreteMethodMetaHelper	(	const char *	name,
		Private::ArgumentTuple< Args... >	,
		Description &&...	descriptions
	)

inlineprotected

◆ createMethodMeta()

void createMethodMeta	(	const std::string &	name,
		Comment &&	comment,
		Descriptions &&...	args
	)

inlineprotected

◆ property() [1/10]

void property	(	const char *	name,
		T &	member,
		const char *	comment,
		PropertyHint &&	hint = `PropertyHint()`,
		ReflectCtrlFlags	flags = `REFLECT_CTRLFLAG_NONE`
	)

inline

◆ property() [2/10]

void property	(	const char *	name,
		const std::string &	id,
		T &	member,
		const char *	comment,
		PropertyHint &&	hint = `PropertyHint()`,
		ReflectCtrlFlags	flags = `REFLECT_CTRLFLAG_NONE`
	)

inline

◆ property() [3/10]

void property	(	const char *	name,
		const T &	member,
		Setter< T >	setter,
		const char *	comment,
		PropertyHint &&	hint = `PropertyHint()`,
		ReflectCtrlFlags	flags = `REFLECT_CTRLFLAG_NONE`
	)

inline

◆ property() [4/10]

void property	(	const char *	name,
		Getter< T >	getter,
		Setter< T >	setter,
		const char *	comment,
		PropertyHint &&	hint = `PropertyHint()`,
		ReflectCtrlFlags	flags = `REFLECT_CTRLFLAG_NONE`
	)

inline

◆ property() [5/10]

void property	(	const char *	name,
		T &	member,
		const char *	comment,
		const U &	defaultValue,
		PropertyHint &&	hint = `PropertyHint()`,
		ReflectCtrlFlags	flags = `REFLECT_CTRLFLAG_NONE`
	)

inline

◆ property() [6/10]

void property	(	const char *	name,
		const T &	member,
		Setter< T >	setter,
		const char *	comment,
		const U &	defaultValue,
		PropertyHint &&	hint = `PropertyHint()`,
		ReflectCtrlFlags	flags = `REFLECT_CTRLFLAG_NONE`
	)

inline

◆ property() [7/10]

void property	(	const char *	name,
		Getter< T >	getter,
		Setter< T >	setter,
		const char *	comment,
		const U &	defaultValue,
		PropertyHint &&	hint = `PropertyHint()`,
		ReflectCtrlFlags	flags = `REFLECT_CTRLFLAG_NONE`
	)

inline

◆ delegate() [1/3]

void delegate	(	T &	member,
		ReflectCtrlFlags	flags = `REFLECT_CTRLFLAG_NONE`
	)

inline

◆ delegate() [2/3]

void delegate	(	const T &	member,
		Setter< T >	setter,
		ReflectCtrlFlags	flags = `REFLECT_CTRLFLAG_NONE`
	)

inline

◆ delegate() [3/3]

void delegate	(	Getter< T >	getter,
		Setter< T >	setter,
		ReflectCtrlFlags	flags = `REFLECT_CTRLFLAG_NONE`
	)

inline

◆ collectionItems()

void collectionItems	(	const std::string &	countName,
		bool	blockdump = `false`
	)

inline

◆ version() [4/6]

VersionType version	(	VersionType	version,
		const T *	caller = `NULL`
	)

inlineinherited

◆ version() [5/6]

VersionType version	(	VersionType	version,
		AcceptDesiredVersion	,
		const T *	caller = `NULL`
	)

inlineinherited

◆ version() [6/6]

VersionType version	(	VersionType	version,
		AcceptDesiredVersion	,
		const T *	caller = `NULL`
	)

inlineinherited

Extension of version() (see above), that additionally signals the reflector that the caller will properly handle a different version than the one it specifies itself.

◆ MIRA_DEPRECATED() [2/5]

MIRA_DEPRECATED	(	"Please call as requireVersion<MyType>(v, minV) or requireVersion(v, minV, this)"	,
		VersionType	requireVersionVersionType version, VersionType minVersion
	)

inlineinherited

◆ MIRA_DEPRECATED() [3/5]

MIRA_DEPRECATED	(	"Please call as requireVersion<MyType>(v) or requireVersion(v, this)"	,
		void	requireVersionVersionType requiredVersion
	)

inlineinherited

◆ MIRA_DEPRECATED() [4/5]

MIRA_DEPRECATED	(	"Please call as requireVersion<MyType>(v, minV) or requireVersion(v, minV, this)"	,
		VersionType	requireVersionVersionType version, VersionType minVersion
	)

inlineinherited

Deprecated 'anonymous' (no type) requireVersion().

◆ MIRA_DEPRECATED() [5/5]

MIRA_DEPRECATED	(	"Please call as requireVersion<MyType>(v) or requireVersion(v, this)"	,
		VersionType	requireVersionVersionType version
	)

inlineinherited

Deprecated 'anonymous' (no type) requireVersion().

◆ forcedSerializeVersion()

static int forcedSerializeVersion ( )

inlinestaticinherited

Returns either the version number from value of environment variable 'MIRA_FORCE_SERIALIZE_VERSION', or -1 (= do not force a version).

◆ desireClassVersions()

void desireClassVersions ( const ClassVersionMap & versions )

inlineinherited

implements ReflectorInterface (for documentation see ReflectorInterface)

◆ queryDesiredClassVersion() [1/2]

VersionType queryDesiredClassVersion	(	VersionType	version,
		const std::string &	type,
		bool	acceptDesiredVersion = `false`
	)

inlineprotectedinherited

◆ queryDesiredClassVersion() [2/2]

VersionType queryDesiredClassVersion	(	VersionType	version,
		bool	acceptDesiredVersion = `false`
	)

inlineprotectedinherited

◆ serialize()

void serialize	(	const std::string &	name,
		const T &	value,
		const std::string &	comment = `""`
	)

inlineinherited

Serializes the specified object value under the given name.

If you overwrite this method in a derived class you usually MUST call this method of the base class.

◆ trackObject()

void trackObject ( T & member )

inlineinherited

◆ pointerNormal()

void pointerNormal	(	T *&	pointer,
		int	typeId
	)

inlineinherited

◆ pointerPolymorphic()

void pointerPolymorphic	(	T *&	pointer,
		int	typeId
	)

inlineinherited

◆ pointerAbstract()

void pointerAbstract	(	T *&	pointer,
		int	typeId
	)

inlineinherited

◆ pointerReference()

void pointerReference ( int referencedObjectID )

inlineinherited

Is called by the pointer() method if an object, a pointer references, was already serialized and a reference to that object must be stored instead of the whole object.

This method can be implemented by derived concrete serializers to store pointer references.

◆ pointerNull()

void pointerNull ( )

inlineinherited

Is called by the pointer() method to indicate that a pointer that is to be serialized is a NULL-pointer.

It can be implemented by derived concrete serializers to handle the special NULL-pointer case.

◆ pointerWithoutClassType()

void pointerWithoutClassType ( )

inlineinherited

Is called if a pointer points to a non-polymorphic type and hence the object can be stored without specifying a class type.

It can be implemented by derived concrete serializers to indicate that no pointer reference and no class type needs to be stored and the full object will follow afterwards. (this is used by the BinarySerializer)

◆ pointerWithClassType()

void pointerWithClassType ( const std::string & type )

inlineinherited

Is called if a pointer points to a polymorphic type and hence the object must be stored with specifying a class type.

It can be implemented by derived concrete serializers to indicate that no pointer reference is stored, but that the full object is serialized afterwards and to store the class type that is needed for proper deserialization.

◆ isTrackingEnabled()

bool isTrackingEnabled ( ) const

inlineprotectedinherited

Returns true, if object tracking is enabled for the type T.

◆ pushObjectTrackingStore()

void pushObjectTrackingStore ( )

inlineinherited

◆ popObjectTrackingStore()

void popObjectTrackingStore ( )

inlineinherited

◆ getHumanReadableFullID()

const std::string& getHumanReadableFullID ( int objectID ) const

inlineprotectedinherited

Returns the full human readable object id / name for the given internal objectID.

The human readable id only is available, if the Reflector has set useHumanReadableIDs to true.

◆ member() [1/10]

void member	(	const char *	name,
		T &	member,
		const char *	comment,
		ReflectCtrlFlags	flags = `REFLECT_CTRLFLAG_NONE`
	)

inlineinherited

◆ member() [2/10]

void member	(	const char *	name,
		const std::string &	id,
		T &	member,
		const char *	comment,
		ReflectCtrlFlags	flags = `REFLECT_CTRLFLAG_NONE`
	)

inlineinherited

◆ member() [3/10]

void member	(	const char *	name,
		const T &	member,
		Setter< T >	setter,
		const char *	comment,
		ReflectCtrlFlags	flags = `REFLECT_CTRLFLAG_NONE`
	)

inlineinherited

◆ member() [4/10]

void member	(	const char *	name,
		Getter< T >	getter,
		Setter< T >	setter,
		const char *	comment,
		ReflectCtrlFlags	flags = `REFLECT_CTRLFLAG_NONE`
	)

inlineinherited

◆ member() [5/10]

void member	(	const char *	name,
		T &	member,
		const char *	comment,
		const T &	defaultValue,
		ReflectCtrlFlags	flags = `REFLECT_CTRLFLAG_NONE`
	)

inlineinherited

◆ member() [6/10]

void member	(	const char *	name,
		T &	member,
		const char *	comment,
		const U &	defaultValue,
		ReflectCtrlFlags	flags = `REFLECT_CTRLFLAG_NONE`
	)

inlineinherited

◆ member() [7/10]

void member	(	const char *	name,
		const T &	member,
		Setter< T >	setter,
		const char *	comment,
		const T &	defaultValue,
		ReflectCtrlFlags	flags = `REFLECT_CTRLFLAG_NONE`
	)

inlineinherited

◆ member() [8/10]

void member	(	const char *	name,
		const T &	member,
		Setter< T >	setter,
		const char *	comment,
		const U &	defaultValue,
		ReflectCtrlFlags	flags = `REFLECT_CTRLFLAG_NONE`
	)

inlineinherited

◆ member() [9/10]

void member	(	const char *	name,
		Getter< T >	getter,
		Setter< T >	setter,
		const char *	comment,
		const T &	defaultValue,
		ReflectCtrlFlags	flags = `REFLECT_CTRLFLAG_NONE`
	)

inlineinherited

◆ member() [10/10]

void member	(	const char *	name,
		Getter< T >	getter,
		Setter< T >	setter,
		const char *	comment,
		const U &	defaultValue,
		ReflectCtrlFlags	flags = `REFLECT_CTRLFLAG_NONE`
	)

inlineinherited

◆ property() [8/10]

void property	(	const char *	name,
		T &	member,
		const char *	comment,
		const T &	defaultValue,
		PropertyHint &&	hint = `PropertyHint()`,
		ReflectCtrlFlags	flags = `REFLECT_CTRLFLAG_NONE`
	)

inlineinherited

◆ property() [9/10]

void property	(	const char *	name,
		const T &	member,
		Setter< T >	setter,
		const char *	comment,
		const T &	defaultValue,
		PropertyHint &&	hint = `PropertyHint()`,
		ReflectCtrlFlags	flags = `REFLECT_CTRLFLAG_NONE`
	)

inlineinherited

◆ property() [10/10]

void property	(	const char *	name,
		Getter< T >	getter,
		Setter< T >	setter,
		const char *	comment,
		const T &	defaultValue,
		PropertyHint &&	hint = `PropertyHint()`,
		ReflectCtrlFlags	flags = `REFLECT_CTRLFLAG_NONE`
	)

inlineinherited

◆ collection()

void collection ( T & member )

inlineinherited

Is called for each complex object or array, where the IsCollection<T> trait is true_type.

The default implementation calls object().

◆ registerClass()

static void registerClass ( )

inlinestaticinherited

Registers a new polymorphic class at the PolymorphPointerReflector.

Each RecursiveMemberReflector only is able to process pointers to polymorphic classes that are registered using this method.

The MIRA_CLASS_SERIALIZATION macro provides a simple mechanism to register a class in all known MemberReflectors and calls their registerClass() method. If you implement a new MemberReflector you should modify the MIRA_CLASS_SERIALIZATION macro and add your reflector there.

See also: MIRA_CLASS_SERIALIZATION

◆ unregisterClass()

static void unregisterClass ( )

inlinestaticinherited

Unregisters the class.

The MIRA_CLASS_SERIALIZATION macro provides a simple mechanism to register a class in all known MemberReflectors and calls their registerClass() method. If you implement a new MemberReflector you should modify the MIRA_CLASS_SERIALIZATION macro and add your reflector there.

See also: MIRA_CLASS_SERIALIZATION

◆ getCurrentMemberMeta()

const ReflectMemberMeta& getCurrentMemberMeta ( ) const

inlineinherited

Returns the meta-information of the current member that is reflected.

◆ getCurrentMemberFullID()

const std::string& getCurrentMemberFullID ( ) const

inlineinherited

Returns the full human readable object id / name of the current member being reflected.

This method must not be called if the Reflector has set useHumanReadableIDs to false. If it is called anyway we will assert here.

◆ isReflectedAsPointer()

static bool isReflectedAsPointer ( )

inlinestaticinherited

For internal use only: Returns true, if the type T is ever reflected as pointer within the current translation unit (C file).

◆ invokeTrackObject()

void invokeTrackObject ( T & member )

inlineprotectedinherited

tracks the given object (if pointer tracking is enabled for type T)

◆ reflectUnknown()

void reflectUnknown ( T & member )

inlineprotectedinherited

◆ reflectAtomic()

void reflectAtomic ( T & member )

inlineprotectedinherited

Type A1: for atomic members (float,int,etc.)

◆ reflectEnumeration()

void reflectEnumeration ( T & member )

inlineprotectedinherited

Type A2: for enums.

◆ reflectArray()

void reflectArray ( T & member )

inlineprotectedinherited

Type A3: for arrays.

◆ reflectComplex()

void reflectComplex ( T & member )

inlineprotectedinherited

Type B1/B2: for complex types.

◆ reflectCollection()

void reflectCollection ( T & member )

inlineprotectedinherited

Type B?c: for collection types.

◆ reflectPointer()

void reflectPointer ( T & member )

inlineprotectedinherited

Type C: for members that are pointers.

◆ reflectPointerNormal()

void reflectPointerNormal ( T *& member )

inlineprotectedinherited

Type C1: for members that are pointers to normal classes.

◆ reflectPointerPolymorphic()

void reflectPointerPolymorphic ( T *& member )

inlineprotectedinherited

Type C2: for members that are pointers to polymorphic classes derived from mira::Object.

◆ reflectPointerAbstract()

void reflectPointerAbstract ( T *& member )

inlineprotectedinherited

Type C3: for members that are pointers to abstract classes not derived from mira::Object.

◆ chooseReflect()

void chooseReflect ( T & member )

inlineprotectedinherited

Detect the members type (A1,A2,A3,B1,B2,C) and choose the appropriate function.

◆ invokeMember()

void invokeMember	(	T &	member,
		const ReflectMemberMeta &	meta
	)

inlineinherited

Is called to invoke this Reflector on the member with the specified meta information.

This method delegates the call to the most derived invokeMemberOverwrite() method that may be overwritten in subclasses.

Note: Usually, the RecursiveMemberReflector should be invoked using this invokeMember() method instead of the invoke() method of the ReflectorInterface base class. The invoke() method is called internally by the RecursiveMemberReflector.

◆ invokeMemberOverwrite()

void invokeMemberOverwrite	(	T &	member,
		const ReflectMemberMeta &	meta
	)

inlineinherited

The actual invokeMember implementation that is called from invokeMember().

This method may be overwritten in derived classes to add additional functionality, however, you should always call this implementation of the base class.

◆ invokePointerObject()

void invokePointerObject ( T & member )

inlineinherited

Is called to reflect objects of pointers.

They will use the same meta as the pointer

◆ invokeMemberWithoutDefault()

void invokeMemberWithoutDefault	(	T &	member,
		const ReflectMemberMeta &	meta
	)

inlineinherited

Delegates to invokeMember() and rethrows any occurring XMemberNotFound exception as XIO exception.

◆ invokeMemberWithDefault() [1/2]

void invokeMemberWithDefault	(	T &	member,
		const ReflectMemberMeta &	meta,
		const U &	defaultValue
	)

inlineinherited

Delegates to invokeMember() and handles any occurring XMemberNotFound exception by setting the member to the given default value.

◆ invokeMemberWithDefault() [2/2]

void invokeMemberWithDefault	(	T &	member,
		const ReflectMemberMeta &	meta,
		const serialization::IgnoreMissing &	defaultValue
	)

inlineinherited

Delegates to invokeMember() and handles any occurring XMemberNotFound exception by ignoring the exception and hence the missing member, as indicated by IgnoreMissing as default value.

The value of the member remains unchanged.

◆ requireVersion() [1/8]

VersionType requireVersion	(	VersionType	version,
		VersionType	minVersion,
		const T *	caller = `NULL`
	)

inlineinherited

implements ReflectorInterface (for documentation see ReflectorInterface)

◆ requireVersion() [2/8]

void requireVersion	(	VersionType	requiredVersion,
		const T *	caller = `NULL`
	)

inlineinherited

implements ReflectorInterface (for documentation see ReflectorInterface)

◆ requireVersion() [3/8]

VersionType requireVersion	(	VersionType	version,
		VersionType	minVersion,
		AcceptDesiredVersion	,
		const T *	caller = `NULL`
	)

inlineinherited

implements ReflectorInterface (for documentation see ReflectorInterface)

◆ requireVersion() [4/8]

void requireVersion	(	VersionType	requiredVersion,
		AcceptDesiredVersion	,
		const T *	caller = `NULL`
	)

inlineinherited

implements ReflectorInterface (for documentation see ReflectorInterface)

◆ requireVersion() [5/8]

VersionType requireVersion	(	VersionType	version,
		VersionType	minVersion,
		const T *	caller = `NULL`
	)

inlineinherited

Same as above, but allows to specify a minimum supported version, and throws XIO if the minimum version requirement is not met.

Calls version() internally.

Usage:

template<typename Reflector>
void reflect(Reflector& r)
{
    VersionType v = r.requireVersion(4, 2, this); // specifies version 4,
                                                  // requires version 2 or higher
    if(v==3) { // handle reading version 3
       ...
    } else     // only versions 2 or 4 remain
    ...
}

Note: Specifying versions for serialized classes is optional.; requireVersion() and version() currently are supported by serialization reflectors only

◆ requireVersion() [6/8]

void requireVersion	(	VersionType	version,
		const T *	caller = `NULL`
	)

inlineinherited

Specifies the current class version, which is also the minimum (and therefore only) version accepted (therefore, no need to return a version number).

See above.

◆ requireVersion() [7/8]

VersionType requireVersion	(	VersionType	version,
		VersionType	minVersion,
		AcceptDesiredVersion	,
		const T *	caller = `NULL`
	)

inlineinherited

Extension of requireVersion() (see above), that additionally signals the reflector that the caller will properly handle a different version than the one it specifies itself.

◆ requireVersion() [8/8]

void requireVersion	(	VersionType	version,
		AcceptDesiredVersion	,
		const T *	caller = `NULL`
	)

inlineinherited

Extension of requireVersion() (see above), that additionally signals the reflector that the caller will properly handle a different version than it one it specifies itself.

◆ reflectBase()

void reflectBase ( Base & base )

inlineinherited

implements ReflectorInterface (for documentation see ReflectorInterface)

◆ This()

MetaSerializer * This ( )

inlineprotectedinherited

"Curiously recurring template pattern" (CRTP).

Safely casts this into Derived. This is safe since when implementing derived class their type is passed as template parameter.

See Wikipedia for more details on CRTP if necessary!

◆ invoke()

void invoke ( T & object )

inlineprotectedinherited

Invokes this reflector on the specified object.

This is like calling object.reflect(*this). However, this automatically examines if the class T contains a reflect method. In this case it calls the intrusive reflect method, otherwise it uses the non-intrusive reflect method.

◆ reflectComplexIntrusive()

void reflectComplexIntrusive ( T & object )

inlineprotectedinherited

For classes with reflect method call their reflect method directly.

◆ reflectComplexNonintrusive()

void reflectComplexNonintrusive ( T & object )

inlineprotectedinherited

For classes without reflect method, where we need to look somewhere else to get the information for visiting it.

To do so we call a global non-intrusive reflect-function which must be specialized for the visitor and the member type. This allows non-intrusive reflection. If the non-intrusive reflect method does not exist we will get a compiler error here!

◆ reflectMissing()

void reflectMissing ( T & object )

inlineprotectedinherited

◆ roproperty() [1/3]

void roproperty	(	const char *	name,
		const T &	member,
		const char *	comment,
		PropertyHint &&	hint = `PropertyHint()`,
		ReflectCtrlFlags	flags = `REFLECT_CTRLFLAG_NONE`
	)

inlineinherited

A property that just reflects a runtime state of the object and can be displayed but not altered.

◆ roproperty() [2/3]

void roproperty	(	const char *	name,
		const std::string &	id,
		const T &	member,
		const char *	comment,
		PropertyHint &&	hint = `PropertyHint()`,
		ReflectCtrlFlags	flags = `REFLECT_CTRLFLAG_NONE`
	)

inlineinherited

Same as above, with an extra parameter for specifying the id explicitly if it differs from name.

◆ roproperty() [3/3]

void roproperty	(	const char *	name,
		Getter< T >	getter,
		const char *	comment,
		PropertyHint &&	hint = `PropertyHint()`,
		ReflectCtrlFlags	flags = `REFLECT_CTRLFLAG_NONE`
	)

inlineinherited

Same as above, with a special getter method for reading the member.

See also: Getters and Setters

◆ itemName()

void itemName ( const std::string & name )

inlineinherited

If the currently reflected object is an item within a collection, this allows to specify an explicit name for that item.

This currently is interpreted by the PropertySerializer only.

◆ method() [9/10]

void method	(	const char *	name,
		Method	method,
		const char *	comment,
		const char *	paramName,
		const char *	paramDescription,
		P	paramSampleValue,
			...
	)

inherited

Specifies that the class that is reflected provides a service through the specified static member function or free function.

The method will then be available for RPC calls. For each method its name (used to identify the method in RPC calls) and a comment that describes the method must be specified.

Parameters

name	The name of the method (used for calling it)
method	The static member function (or free function) that implements the method
comment	A comment that describes the method
paramName	Optional additional argument(s) for the names of the method's parameters
paramDescription	Optional additional argument(s) for the descriptions of the method's parameters.
paramSampleValue	Optional additional argument(s) providing a sample value for each parameter. These are not default values, they are only used for documentation purpose, and should mainly serve to illustrate notation.

The optional parameter documentation arguments must be either a sequence of pairs of const char* values or a sequence of triplets, where each third value is a value of the respective method parameter's type. (name and description must both be provided, for all parameters or for none, and if sample values are to be added, they also need to be added for all parameters).

Examples:

r.method("myMethod1", myStaticMethod1, "static method that does something");
r.method("myMethod2", myStaticMethod2, "static method that does something else",
         "x", "1st parameter", "y", "2nd parameter");
r.method("myMethod3", myStaticMethod3, "yet another static method"
         "a", "parameter 1", ParamType1(...), "b", "parameter b", ParamType2(...));

◆ method() [10/10]

void method	(	const char *	name,
		Method	method,
		Class *	object,
		const char *	comment,
		const char *	paramName,
		const char *	paramDescription,
		P	paramSampleValue,
			...
	)

inherited

Specifies that the class that is reflected provides a service through the specified non-static member function.

The method will then be available for RPC calls. For each method its name (used to identify the method in RPC calls) and a comment that describes the method must be specified.

Parameters

name	The name of the method (used for calling it)
method	The non-static member function (const or non-const) that implements the method
object	A pointer to the object on which the function is called (usually "this")
comment	A comment that describes the method
paramName	Optional additional argument(s) for the names of the method's parameters
paramDescription	Optional additional argument(s) for the descriptions of the method's parameters.
paramSampleValue	Optional additional argument(s) providing a sample value for each parameter.

See above for documentation of optional parameter documentation arguments.

Example:

r.method("myMethod2", &MyClass::myMethod, this, "a non-static method");

◆ invalid_method()

void invalid_method ( )

inlineinherited

◆ usesHumanReadableIDs()

static bool usesHumanReadableIDs ( )

inlinestaticinherited

Returns true, if the concrete derived Reflector supports human readable IDs.

The return value of this method is known at compile time and hence the compiler is able to optimize the code depending on that value.

◆ postReflect() [2/2]

void postReflect ( const ReflectState & )

inlineinherited

See preReflect for documentation.

◆ checkForcedVersion()

static int checkForcedVersion ( const std::string & variable )

inlinestaticprotectedinherited

Friends And Related Function Documentation

◆ TypeWithoutObjectHelper

friend struct TypeWithoutObjectHelper

friend

◆ TypeWithoutObjectAbstractHelper

friend struct TypeWithoutObjectAbstractHelper

friend

Member Data Documentation

◆ mMetaDatabase

MetaTypeDatabase& mMetaDatabase

protected

◆ mCurrentMeta

TypeMetaPtr mCurrentMeta

protected

◆ mParentMeta

CompoundMetaPtr mParentMeta

protected

◆ mCurrentVersion

CompoundMeta::Member* mCurrentVersion

protected

◆ mDesiredClassVersions

ClassVersionMap mDesiredClassVersions

protectedinherited

◆ mObjects

ObjectSet mObjects

protectedinherited

◆ mObjectIDToName

ObjectIDToNameMap mObjectIDToName

protectedinherited

◆ mTrackingStack

std::stack<TrackingState> mTrackingStack

protectedinherited

◆ MIRA_REFLECTOR_TOPLEVEL_NAME

constexpr auto MIRA_REFLECTOR_TOPLEVEL_NAME

staticprotectedinherited

Use this when a reflector needs to choose a name for serializing an object.

Internally this is used to recognize it is not a name defined by the reflected object, but by the reflector.

The documentation for this class was generated from the following file:

base/include/serialization/MetaSerializer.h

Classes

Public Types

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Friends

Member Typedef Documentation

◆ isObjectTrackingSupported

◆ requireReflectBarriers

◆ ReflectState

◆ VersionType

◆ Tag

◆ AcceptDesiredVersion

◆ isReadOnly

◆ ClassVersionMap

◆ ObjectSet

◆ ObjectIDToNameMap

◆ TrackingState

◆ useHumanReadableIDs

Constructor & Destructor Documentation

◆ MetaSerializer()

Member Function Documentation

◆ addMeta()

◆ version() [1/6]

◆ version() [2/6]

◆ MIRA_DEPRECATED() [1/5]

◆ version() [3/6]

◆ preReflect()

◆ postReflect() [1/2]

◆ write()

◆ hasCodec()

◆ codec()

◆ interface()

◆ addMethod()

◆ method() [1/10]

◆ method() [2/10]

◆ method() [3/10]

◆ method() [4/10]

◆ method() [5/10]

◆ method() [6/10]

◆ method() [7/10]

◆ method() [8/10]

◆ atomic()

◆ enumeration()

◆ pointer()

◆ object()

◆ invokeOverwrite() [1/2]

◆ invokeOverwrite() [2/2]

◆ createMapEntry()

◆ addCurrentAsMemberToParent()

◆ createMeta()

◆ createMetaOrVoidHelper()

◆ createMetaHelper() [1/3]

◆ createMetaHelper() [2/3]

◆ createMetaHelper() [3/3]

◆ concreteMethodMetaHelper()

◆ createMethodMeta()

◆ property() [1/10]

◆ property() [2/10]

◆ property() [3/10]

◆ property() [4/10]

◆ property() [5/10]

◆ property() [6/10]

◆ property() [7/10]

◆ delegate() [1/3]

◆ delegate() [2/3]

◆ delegate() [3/3]

◆ collectionItems()

◆ version() [4/6]

◆ version() [5/6]

◆ version() [6/6]

◆ MIRA_DEPRECATED() [2/5]

◆ MIRA_DEPRECATED() [3/5]

◆ MIRA_DEPRECATED() [4/5]

◆ MIRA_DEPRECATED() [5/5]

◆ forcedSerializeVersion()