MetaSerializer.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 by
 *   MetraLabs GmbH (MLAB), GERMANY
 * and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Contact: info@mira-project.org
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MLAB or NICR.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file. Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MLAB and NICR (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_METASERIALIZER_H_
#define _MIRA_METASERIALIZER_H_

#include <iostream>

#include <type_traits>

#include <platform/Platform.h>
#include <utils/MakeString.h>
#include <utils/IsDefaultConstructible.h>

#include <serialization/BinarySerializer.h>
#include <serialization/IsNotMetaSerializable.h>
#include <serialization/adapters/boost/optional.hpp>
#include <serialization/adapters/std/list>
#include <serialization/adapters/std/vector>

namespace mira {


namespace serialization {


// with c++20 this will be part of the language in std
template <typename T>
struct remove_cvref
{
    typedef typename std::remove_cv<typename std::remove_reference<T>::type>::type type;
};


} // namespace


class TypeMeta : public std::vector<uint8>
{
    typedef std::vector<uint8> Base;
public:

    enum Type {
        TYPE_INVALID = 0,
        TYPE_VOID,

        // class type, (typename is stored in mIdentifier)
        TYPE_CLASS,

        // user-defined atomic type (typename is stored in mIdentifier)
        TYPE_ATOMIC,

        // built-in atomic types (mIdentifier stays empty)
        TYPE_UINT8 , TYPE_INT8,
        TYPE_UINT16, TYPE_INT16,
        TYPE_UINT32, TYPE_INT32,
        TYPE_UINT64, TYPE_INT64,
        TYPE_FLOAT , TYPE_DOUBLE,
        TYPE_BOOL,
        TYPE_STRING,
        TYPE_ENUMERATION,
        TYPE_VERSION,

        LAST_TYPE_FIELD
    };

    enum TypeQualifier {
        NO_QUALIFIER=0,
        // first value must be larger than last value in TypeField
        FIRST_TYPE_QUALIFIER = 0x20,
        TYPE_COLLECTION = FIRST_TYPE_QUALIFIER,
        TYPE_POINTER,
        TYPE_PROPERTY
    };

    // this version is the format version of the TypeMeta
    // only deviate from default if you really know what you are doing!
    TypeMeta(uint8 version = 2) : mVersion(version) {}

    template<typename Reflector>
    void reflect(Reflector& r) {
        MIRA_REFLECT_BASE(r,Base);
        if(getType()==TYPE_ATOMIC || getType()==TYPE_CLASS)
            r.member("Identifier", mIdentifier, "The identifier of the class "
                     "or 'complex' atomic type");
        r.member("Version", mVersion, "The metatype format version", 2);
    }

    template<typename BinaryStream>
    void reflect(ConcreteBinaryDeserializer<BinaryStream, 0>& r) {
        MIRA_REFLECT_BASE(r,Base);
        if(getType()==TYPE_ATOMIC || getType()==TYPE_CLASS)
            r.member("Identifier", mPlainIdentifier, "The identifier of the class "
                     "or 'complex' atomic type", REFLECT_CTRLFLAG_TEMP_TRACKING);
        mVersion = 0;
        if (getType()==TYPE_CLASS)
            mIdentifier += mPlainIdentifier + " @v0";
        else
            mIdentifier = mPlainIdentifier; 
    }

    // just in case someone tries to use it...
    template<typename BinaryStream>
    void reflect(ConcreteBinarySerializer<BinaryStream, 0>& r) {
        MIRA_REFLECT_BASE(r,Base);
        if(getType()==TYPE_ATOMIC || getType()==TYPE_CLASS)
            r.member("Identifier", mPlainIdentifier, "The identifier of the class "
                     "or 'complex' atomic type", REFLECT_CTRLFLAG_TEMP_TRACKING);
    }

    void addQualifier(TypeQualifier qualifier) {
        assert(Base::size()>=1);
        push_back(qualifier);
    }

    void setBaseAtomicType(Type type) {
        assert(type!=TYPE_CLASS && type!=TYPE_ATOMIC && type!=TYPE_INVALID);
        assert(Base::size()==0);
        push_back(type);
    }

    void setAtomicType(const std::string& typenam);

    template <typename T>
    void setAtomicType() { setAtomicType(typeName<T>()); }

    void setClassType(const std::string& identifier) {
        assert(Base::size()==0);
        push_back(TYPE_CLASS);
        mIdentifier = identifier;
        mPlainIdentifier = mIdentifier;
    }

    template <typename T>
    void setType() {
        if constexpr (IsAtomicSerializable<T>::value)
            setAtomicType<T>();
        else
            setClassType(typeName<T>());
    }

    Type getType() const {
        if(empty() || front() >= LAST_TYPE_FIELD)
            return TYPE_INVALID;
        return (Type)front();
    }

    bool hasQualifier() const {
        return Base::size()>1;
    }

    int qualifierCount() const {
        return std::max(size()-1,0);
    }

    TypeQualifier getQualifier(int i=0) const {
        assert(i>=0);
        if(i>=qualifierCount())
            return NO_QUALIFIER;
        return (TypeQualifier)Base::at(size()-i-1);
    }

    void removeQualifiers(int n)
    {
        assert(n>=0);
        if(n>qualifierCount())
            n=qualifierCount();
        return Base::resize(size()-n);
    }

    const std::string& getIdentifier() const {
        return mIdentifier;
    }

    std::string getTypename() const;

    std::string toString() const;

    int size() const { return (int)Base::size(); }

    uint8 version() const { return mVersion; }

private:
    std::string mIdentifier;
    std::string mPlainIdentifier;
    uint8 mVersion;
};

typedef boost::shared_ptr<TypeMeta> TypeMetaPtr;


struct MethodMeta
{
    struct Parameter
    {
        Parameter() {}
        Parameter(TypeMetaPtr iType) :
            type(iType) {}
        Parameter(TypeMetaPtr iType,
                  const std::string& iName,
                  const std::string& iDescription) :
            type(iType),
            name(iName),
            description(iDescription) {}

        template<typename Reflector>
        void reflect(Reflector& r)
        {
            r.member("Type",type,"The meta type info of the parameter");
            r.member("Name",name,"The name of the parameter");
            r.member("Description",description,"The description for the parameter");
        }

        TypeMetaPtr type;
        std::string name;
        std::string description;
    };

    MethodMeta() {}
    MethodMeta(const std::string& iName,
               const std::string& iComment) :
        name(iName),
        comment(iComment) {}

    template<typename Reflector>
    void reflect(Reflector& r)
    {
        r.member("Name",name,"The name of the method");
        r.member("Comment",comment,"The user defined comment");
        r.member("ReturnType",returnType,"The meta type info of the return type");
        r.member("Parameters",parameters,"A list with type infos for each parameter");
    }

    std::string name;
    std::string comment;
    TypeMetaPtr returnType;
    std::list<Parameter> parameters;
};

typedef boost::shared_ptr<MethodMeta> MethodMetaPtr;


class CompoundMeta
{
public:
    struct Member
    {
        Member() {}
        Member(TypeMetaPtr iType, const std::string& iName, const std::string& iComment) :
            type(iType), name(iName), comment(iComment) {}

        template<typename Reflector>
        void reflect(Reflector& r)
        {
            r.member("Type", type, "The type of the member");
            r.member("Name", name, "The name of the member");
            r.member("Comment", comment, "The user defined comment");
        }

        TypeMetaPtr type;
        std::string name;
        std::string comment;
    };

    typedef serialization::VersionType VersionType;

    template<typename Reflector>
    void reflect(Reflector& r)
    {
        VersionType v = r.requireVersion(2, 1, this);

        if (v < 2) {
            boost::optional<int> optVersion; // version was int32 back then
            r.member("Version",optVersion,"The version of the serialization format");

            if (optVersion)
                version[""] = *optVersion;
        } else
            r.member("Version",version,"The version of the serialization format");

        r.member("Members",members,"The members of the compound");
        r.member("Interfaces",interfaces,"The supported interfaces");
        r.member("Methods",methods,"The reflected methods");
    }

    template<typename BinaryStream>
    void reflect(ConcreteBinarySerializer<BinaryStream, 0>& r) {
        r.version(1, this);                        // version 2 of CompoundMeta was unknown back then

        boost::optional<int> optVersion;           // serialization version type was int32 back then
        if (!version.empty())
            optVersion = version.cbegin()->second; // we assume the version of the serialized class did not change
                                                   // from v0, otherwise it will be unreadable for the recipient anyway
                                                   // --> it can have only one or no version at all now
        r.member("Version",optVersion,"The version of the serialization format");

        r.member("Members",members,"The members of the compound");
        r.member("Interfaces",interfaces,"The supported interfaces");
        r.member("Methods",methods,"The reflected methods");
    }

    void addMember(const ReflectMemberMeta& memberMeta, TypeMetaPtr type)
    {
        addMember(memberMeta.id, memberMeta.comment, type);
    }

    void addMember(const std::string& name, TypeMetaPtr type)
    {
        addMember(name, "", type);
    }

    void addMember(const std::string& name, const std::string& comment, TypeMetaPtr type)
    {
        members.push_back(Member(type, name, comment));
    }

    void insertMember(const std::string& name, TypeMetaPtr type, int index)
    {
        std::list<Member>::iterator pos = members.begin();
        while ((pos != members.end()) && (index-- > 0))
            ++pos;
        members.insert(pos, Member(type, name, ""));
    }

    void insertMember(const std::string& name, TypeMetaPtr type, const std::string& before)
    {
        std::list<Member>::iterator pos = members.begin();
        while ((pos != members.end()) && (pos->name != before))
            ++pos;
        members.insert(pos, Member(type, name, ""));
    }

    void addInterface(const std::string& iface)
    {
        interfaces.push_back(iface);
    }

    void addMethod(const MethodMetaPtr& method)
    {
        methods.push_back(method);
    }

    void setVersion(VersionType version) {
        this->version[""] = version;
    }

    void setVersion(const std::string& type, VersionType version) {
        this->version[type] = version;
    }

    std::string toString() const;

    std::map<std::string, VersionType> version;
    std::list<Member>  members;
    std::list<std::string> interfaces;
    std::list<MethodMetaPtr> methods;
};

typedef boost::shared_ptr<CompoundMeta> CompoundMetaPtr;

class MetaTypeDatabase : public std::map<std::string, CompoundMetaPtr>
{
    typedef std::map<std::string, CompoundMetaPtr> Base;
public:

    MetaTypeDatabase() {}
    MetaTypeDatabase(const MetaTypeDatabase& other) :
        Base(other) {}
    MetaTypeDatabase& operator=(const MetaTypeDatabase& other)
    {
        Base::operator=(other);
        return *this;
    }

    template<typename Reflector>
    void reflect(Reflector& r)
    {
        MIRA_REFLECT_BASE(r,Base);
    }

    template<typename BinaryStream>
    void reflect(ConcreteBinaryDeserializer<BinaryStream, 0>& r)
    {
        MIRA_REFLECT_BASE(r,Base);

        // mark all loaded type keys as '@v0' (TypeMetas in entries are also marked by TypeMeta::reflect())
        MetaTypeDatabase db;
        foreach (auto p, *this)
            db[p.first+" @v0"] = p.second;

        swap(db);
    }

    // just in case...
    template<typename BinaryStream>
    void reflect(ConcreteBinarySerializer<BinaryStream, 0>& r)
    {
        MetaTypeDatabase db;
        foreach (auto p, *this) {
            // if tagged ' @v0', remove tag, else ignore
            size_t s = p.first.size();
            if (p.first.substr(s-4, std::string::npos) == " @v0")
                db[p.first.substr(0, s-4)] = p.second;
        }

        r.template reflectBase<Base>(db);
    }

    void merge(const MetaTypeDatabase& other)
    {
        this->insert(other.begin(), other.end());
    }

    MetaTypeDatabase getDependentTypesDB(TypeMetaPtr type)
    {
        MetaTypeDatabase db;
        generateDependentTypesDB(type, db);
        return db;
    }

private:

    void generateDependentTypesDB(TypeMetaPtr type, MetaTypeDatabase& db);
};

template <>
class IsCollection<MetaTypeDatabase> : public std::true_type {};


class MetaSerializer : public BinarySerializer<MetaSerializer>
{
    typedef BinarySerializer<MetaSerializer> Base;

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

    typedef boost::mpl::bool_<true> requireReflectBarriers;
    typedef CompoundMeta::Member* ReflectState;

public:

    MetaSerializer(MetaTypeDatabase& database) :
        mMetaDatabase(database) {}

    template<typename T>
    TypeMetaPtr addMeta(const T& v)
    {
#ifdef CHECK_FORCE_SERIALIZE_BINARY_VERSION
        int vf = Serializer::forcedSerializeVersion();
        if ((vf >= 0) && (vf < BinaryBufferSerializer::getSerializerFormatVersion()))
            return TypeMetaPtr(); //disable meta serialization if an older binary format is forced
#endif
        try
        {
            mCurrentMeta.reset();
            mParentMeta.reset();
            serialize(MIRA_REFLECTOR_TOPLEVEL_NAME, v);
            return mCurrentMeta;
        }
        catch(XNotImplemented&)
        {
            return TypeMetaPtr(); //return a null ptr as we are not able to extract meta information
        }
    }

    typedef serialization::VersionType VersionType;

private:

    void setVersion(VersionType version, const std::string& type,
                    const std::string& versionString) {
        if(mParentMeta)
            mParentMeta->setVersion(type, version);

        mCurrentVersion->name = versionString;
        mCurrentVersion->comment = "";
    }

protected:

    // required for subclasses that can only tell the type by name (e.g. Python toolbox)
    VersionType version(VersionType version, const std::string& type,
                        bool acceptDesiredVersion = false) {
        version = this->queryDesiredClassVersion(version, type, acceptDesiredVersion);
        setVersion(version, type, "@version[" + type + "]");
        return version;
    }

public:

    template <typename T>
    VersionType version(VersionType version, const T* caller = NULL) {
        return this->version(version, typeName<T>(), false);
    }

    MIRA_DEPRECATED("Please call as version<MyType>(v) or version(v, this)",
    VersionType version(VersionType version)) {
        if(mParentMeta)
            mParentMeta->setVersion(version);

        mCurrentVersion->name = std::string("@version");

        return version;
    }

    template <typename T>
    VersionType version(VersionType version, AcceptDesiredVersion, const T* caller = NULL) {
        return this->version(version, typeName<T>(), true);
    }

public:

    ReflectState preReflect(const char* context = "")
    {
        ReflectState state = mCurrentVersion;

        mCurrentMeta.reset(new TypeMeta);
        mCurrentMeta->setBaseAtomicType(TypeMeta::TYPE_VERSION);
        if(mParentMeta) {
            mParentMeta->addMember("@version_default", std::string("implicit: ") + context, mCurrentMeta);
            mCurrentVersion = &(mParentMeta->members.back());
        }

        return state;
    }

    void postReflect(const ReflectState& prev)
    {
        mCurrentVersion = prev;
    }

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

    }

    template <typename T>
    bool hasCodec() const {
        return false;
    }

    template <typename T>
    bool codec(const T& obj)
    {
        return false;
    }

    void interface(const char* name)
    {
        assert(name != NULL); // check if user has specified NULL as interface name
        if(mParentMeta)
            mParentMeta->addInterface(name);
    }

    void addMethod(MethodMetaPtr method)
    {
        assert(method);
        if (mParentMeta)
            mParentMeta->addMethod(method);
    }

    template<typename R, typename... Args, typename F, typename... Description>
    InvalidRPCDescription<R(Args...), Description...>
    method(const char*, F&&, Description&&...)
    {
        Private::rpc::invalidAssertion<R(Args...), Description...>();
    }

    template<typename F, typename... Description>
    InvalidRPCDescription<F, Description...>
    method(const char*, F&&, Description&&...)
    {
        Private::rpc::invalidAssertion<F, Description...>();
    }

    template<typename R, typename Class, typename... Args, typename... Description>
    InvalidRPCDescription<R (Class::*)(Args...), Description...>
    method(const char*, R (Class::*)(Args...), Class*, Description&&...)
    {
        Private::rpc::invalidAssertion<R (Class::*)(Args...), 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&&...)
    {
        Private::rpc::invalidAssertion<R (Class::*)(Args...) const, Description...>();
    }

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

    {
        createMethodMeta<R, Args...>(name, std::forward<Description>(descriptions)...);
    }

    template<typename F, typename... Description>
    ValidRPCDescription<F, Description...>
    method(const char* name, F&& fn, Description&&... descriptions)
    {
        concreteMethodMetaHelper<typename Private::FunctionTraits<F>::ReturnValue>(
            name, typename Private::FunctionTraits<F>::Arguments{},
            std::forward<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)
    {
        createMethodMeta<R, Args...>(name, std::forward<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)

    {
        createMethodMeta<R, Args...>(name, std::forward<Description>(descriptions)...);
    }

    template<typename T>
    void atomic(T&)
    {
        if constexpr (IsNotMetaSerializable<T>::value)
            MIRA_THROW(XNotImplemented, "Type " << typeName<T>() << " is not meta-serializable");

        mCurrentMeta.reset(new TypeMeta);
        mCurrentMeta->setAtomicType<T>();
        addCurrentAsMemberToParent();
    }

    template<typename T>
    void enumeration(T&)
    {
        if constexpr (IsNotMetaSerializable<T>::value)
            MIRA_THROW(XNotImplemented, "Type " << typeName<T>() << " is not meta-serializable");

        mCurrentMeta.reset(new TypeMeta);
        mCurrentMeta->setBaseAtomicType(TypeMeta::TYPE_ENUMERATION);
        addCurrentAsMemberToParent();
    }

    template<typename T>
    void pointer(T* &pointer)
    {
        if constexpr (IsNotMetaSerializable<T>::value)
            MIRA_THROW(XNotImplemented, "Type " << typeName<T>() << " is not meta-serializable");

        if(pointer!=NULL)
            Base::pointer(pointer);
        else
            TypeWithoutObjectAbstractHelper<T,std::is_abstract<T>::value>::invoke(this);

        assert(mCurrentMeta);
        mCurrentMeta->addQualifier(TypeMeta::TYPE_POINTER);
    }

    template<typename T>
    void object(T& member)
    {
        if constexpr (IsNotMetaSerializable<T>::value)
            MIRA_THROW(XNotImplemented, "Type " << typeName<T>() << " is not meta-serializable");

        mCurrentMeta.reset(new TypeMeta);
        mCurrentMeta->setClassType(typeName<T>());
        addCurrentAsMemberToParent();

        // add us to the global type map
        CompoundMetaPtr compound = createMapEntry(mCurrentMeta);
        if(compound)
        {
            // push on "stack" and create new meta object for first member
            TypeMetaPtr prevCurrentMeta = mCurrentMeta;
            CompoundMetaPtr prevParentMeta = mParentMeta;
            mParentMeta = compound;

            Base::object(member);

            // go "stack" back upwards
            mCurrentMeta = prevCurrentMeta;
            mParentMeta =  prevParentMeta;
        }
        // else we were already reflected, so skip this object
    }

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

        static const std::string context = "invokeOverwrite " + typeName<T>();
        ReflectState state = preReflect(context.c_str());

        Base::invokeOverwrite(object);

        postReflect(state);
    }

    template<typename T>
    void invokeOverwrite(serialization::PlainArray<T>& array)
    {
        static const std::string context = "invokeOverwrite PlainArray<" + typeName<T>() +">";
        ReflectState prevState = preReflect(context.c_str());

        if(this->template isTrackingEnabled<T>() || !IsBitwiseSerializable<T>::value) {
            Base::invokeOverwrite(array);
        } else {
            collectionItems<T>("@itemcount", true);
        }

        postReflect(prevState);
    }


protected:

    CompoundMetaPtr createMapEntry(TypeMetaPtr& type)
    {
        assert(type->getType() == TypeMeta::TYPE_CLASS);
        const std::string& n = type->getIdentifier();

        if(mMetaDatabase.count(n)>0)
            return CompoundMetaPtr();

        CompoundMetaPtr compound(new CompoundMeta);
        mMetaDatabase[n] = compound;
        return compound;
    }

    void addCurrentAsMemberToParent()
    {
        if(mParentMeta)
            mParentMeta->addMember(getCurrentMemberMeta(), mCurrentMeta);
    }

    template <typename T, bool> friend struct TypeWithoutObjectHelper;
    template<typename T, bool>
    struct TypeWithoutObjectHelper {
        static void invoke(MetaSerializer* metaserializer) {
            metaserializer->mCurrentMeta.reset(new TypeMeta);
            metaserializer->mCurrentMeta->setType<T>();
            metaserializer->addCurrentAsMemberToParent();
        }
    };

    template<typename T>
    struct TypeWithoutObjectHelper<T,true> {
        static void invoke(MetaSerializer* metaserializer) {
            T element;
            metaserializer->delegate(element);
        }
    };

    template<typename T>
    struct TypeWithoutObjectHelper<T*,true> {
        static void invoke(MetaSerializer* metaserializer) {
            T* element = NULL;
            metaserializer->delegate(element);
        }
    };

    template <typename T, bool> friend struct TypeWithoutObjectAbstractHelper;
    template<typename T, bool>
    struct TypeWithoutObjectAbstractHelper {
        static void invoke(MetaSerializer* metaserializer) {
            TypeWithoutObjectHelper<T,IsDefaultConstructible<T>::value>::invoke(metaserializer);
        }
    };

    template<typename T>
    struct TypeWithoutObjectAbstractHelper<T,true> {
        static void invoke(MetaSerializer* metaserializer) {
            metaserializer->mCurrentMeta.reset(new TypeMeta);
            metaserializer->mCurrentMeta->setType<T>();
            metaserializer->addCurrentAsMemberToParent();
        }
    };

    template<typename T>
    struct TypeWithoutObjectAbstractHelper<T*,true> {
        static void invoke(MetaSerializer* metaserializer) {
            metaserializer->mCurrentMeta.reset(new TypeMeta);
            metaserializer->mCurrentMeta->setType<T>();
            metaserializer->addCurrentAsMemberToParent();
        }
    };

    template <typename T>
    TypeMetaPtr createMeta()
    {
        // push on "stack" and create new meta object for first member
        TypeMetaPtr prevCurrentMeta = mCurrentMeta;
        CompoundMetaPtr prevParentMeta = mParentMeta;
        mParentMeta.reset();
        if(IsAtomicSerializable<T>::value)
        {
            T* dummy = NULL;
            delegate(*dummy); // is safe, even if element==NULL since atomic never accesses it here
        }
        else
            TypeWithoutObjectAbstractHelper<T,std::is_abstract<T>::value>::invoke(this);

        TypeMetaPtr meta = mCurrentMeta;
        // go "stack" back upwards
        mCurrentMeta = prevCurrentMeta;
        mParentMeta =  prevParentMeta;
        return meta;
    }

    // call this when T could be void, will call the respective overload
    template<typename T>
    TypeMetaPtr createMetaOrVoidHelper()
    {
        typedef typename serialization::remove_cvref<T>::type Type;
        Type* dummy; // just to select the required createMetaHelper() overload
        return createMetaHelper(dummy);
    }

    // can directly call this when not necessary to check for void
    template<typename T>
    TypeMetaPtr createMetaHelper()
    {
        typedef typename serialization::remove_cvref<T>::type Type;
        return createMeta<Type>();
    }

    // different overloads for void/non-void type (can't use void as type here -> use T*/void*)

    template<typename T>
    TypeMetaPtr createMetaHelper(T*)
    {
        return createMeta<T>();
    }

    TypeMetaPtr createMetaHelper(void*)
    {
        TypeMetaPtr meta(new TypeMeta);
        meta->setBaseAtomicType(TypeMeta::TYPE_VOID);
        return meta;
    }

    template<typename R, typename... Args, typename... Description>
    void concreteMethodMetaHelper(const char* name, Private::ArgumentTuple<Args...>,
                                  Description&&... descriptions)
    {
        createMethodMeta<R, Args...>(name, std::forward<Description>(descriptions)...);
    }

    template<typename R, typename ... Args, typename Comment, typename ...Descriptions>
    void createMethodMeta(const std::string& name, Comment&& comment, Descriptions&&... args)
    {
        MethodMetaPtr m(new MethodMeta(name, std::forward<Comment>(comment)));
        m->returnType = createMetaOrVoidHelper<R>();
        addParameterDescription<Args...>(*m, std::forward<Descriptions>(args)...);
        addMethod(std::move(m));
    }

private:
    template<typename... RECURSIONSTOP>
    typename std::enable_if<(sizeof...(RECURSIONSTOP)) == 0>::type addParameterDescription(MethodMeta& m)
    {
    }

    template<typename ParameterType, typename... Args>
    void addParameterDescription(MethodMeta& m)
    {
        m.parameters.push_back(MethodMeta::Parameter(createMetaHelper<ParameterType>()));
        addParameterDescription<Args...>(m);
    }

    template<typename ParameterType, typename... Args, class Name, class Description, typename... Tail,
             typename = typename std::enable_if<(sizeof...(Args)) * 2 == sizeof...(Tail)>::type>
    void addParameterDescription(MethodMeta& m, Name&& name, Description&& description, Tail&&... tail)
    {
        m.parameters.push_back(MethodMeta::Parameter(createMetaHelper<ParameterType>(),
                                                     std::forward<Name>(name),
                                                     std::forward<Description>(description)));
        addParameterDescription<Args...>(m, std::forward<Tail>(tail)...);
    }

    template<typename ParameterType, typename... Args, class Name, class Description, class Example,
             typename... Tail,
             typename = typename std::enable_if<(sizeof...(Args)) * 3 == sizeof...(Tail)>::type>
    void addParameterDescription(MethodMeta& m, Name&& name, Description&& description, Example&& example,
                                 Tail&&... tail)
    {
        m.parameters.push_back(MethodMeta::Parameter(createMetaHelper<ParameterType>(),
                                                     std::forward<Name>(name),
                                                     std::forward<Description>(description)));
        addParameterDescription<Args...>(m, std::forward<Tail>(tail)...);
    }

public:

    // TODO: add the property qualifier just once at the end

    template<typename T>
    void property(const char* name, T& member, const char* comment,
                  PropertyHint&& hint = PropertyHint(),
                  ReflectCtrlFlags flags = REFLECT_CTRLFLAG_NONE) {
        Base::property(name,member,comment,std::move(hint), flags);
        //mCurrentMeta->addQualifier(TypeMeta::TYPE_PROPERTY);
    }

    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) {
        Base::property(name,id,member,comment,std::move(hint), flags);
        //mCurrentMeta->addQualifier(TypeMeta::TYPE_PROPERTY);
    }

    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) {
        Base::property<T>(name,member,setter,comment,std::move(hint), flags);
        //mCurrentMeta->addQualifier(TypeMeta::TYPE_PROPERTY);
    }

    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) {
        Base::property(name,getter,setter,comment,std::move(hint), flags);
        //mCurrentMeta->addQualifier(TypeMeta::TYPE_PROPERTY);
    }

    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) {
        Base::property(name,member,comment,defaultValue,std::move(hint), flags);
        //mCurrentMeta->addQualifier(TypeMeta::TYPE_PROPERTY);
    }

    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) {
        Base::property(name,member,setter,comment,defaultValue, std::move(hint), flags);
        //mCurrentMeta->addQualifier(TypeMeta::TYPE_PROPERTY);
    }

    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) {
        Base::property(name,getter,setter,comment,defaultValue,std::move(hint), flags);
        //mCurrentMeta->addQualifier(TypeMeta::TYPE_PROPERTY);
    }

    template<typename T>
    void delegate(T& member, ReflectCtrlFlags flags = REFLECT_CTRLFLAG_NONE) {
        if (flags & REFLECT_CTRLFLAG_TEMP_TRACKING) {
            this->This()->pushObjectTrackingStore();
            this->invokeMember(member, ReflectMemberMeta("@transparent", "@transparent", "delegated") );
            this->This()->popObjectTrackingStore();
        } else
            this->invokeMember(member, ReflectMemberMeta("@transparent", "@transparent", "delegated") );
    }

    template<typename T>
    void delegate(const T& member, Setter<T> setter,
                  ReflectCtrlFlags flags = REFLECT_CTRLFLAG_NONE) {
        auto a = makeAccessor(member, setter);
        this->This()->pushObjectTrackingStore();
        this->invokeMember(a, ReflectMemberMeta("@transparent", "@transparent", "delegated") );
        this->This()->popObjectTrackingStore();
    }

    template<typename T>
    void delegate(Getter<T> getter, Setter<T> setter,
                  ReflectCtrlFlags flags = REFLECT_CTRLFLAG_NONE) {
        auto a = makeAccessor(getter, setter);
        this->This()->pushObjectTrackingStore();
        this->invokeMember(a, ReflectMemberMeta("@transparent", "@transparent", "delegated") );
        this->This()->popObjectTrackingStore();
    }

    template<typename T>
    void collectionItems(const std::string& countName, bool blockdump = false)
    {
        TypeWithoutObjectAbstractHelper<T,std::is_abstract<T>::value>::invoke(this);

        assert(mCurrentMeta);
        mCurrentMeta->addQualifier(TypeMeta::TYPE_COLLECTION);

        assert(mParentMeta);
        if (blockdump) {
            mParentMeta->members.back().name = "@items_blockdump";
            mParentMeta->members.back().comment = countName;
        } else {
            mParentMeta->members.back().name = "@items";
            mParentMeta->members.back().comment = countName;
        }
    }

protected:

    MetaTypeDatabase& mMetaDatabase;
    TypeMetaPtr     mCurrentMeta;
    CompoundMetaPtr mParentMeta;

    CompoundMeta::Member* mCurrentVersion;
};



template<typename T>
class IsTransparentSerializableHelper<T, MetaSerializer> : public std::false_type {};

template<typename T>
class IsTransparentSerializableHelper<serialization::PlainArray<T>, MetaSerializer> : public std::true_type {};

namespace serialization {


template<typename Container>
struct ReflectCollectionItems<MetaSerializer, Container>
{
    static void reflect(MetaSerializer& r, Container& c)
    {
        typedef typename Container::value_type rawtype;
        typedef typename remove_cvref<rawtype>::type type;

        r.template collectionItems<type>("@itemcount");
    }
};

template<typename Allocator>
struct ReflectReadBoolVectorItems<MetaSerializer, Allocator>
{
    static void reflect(MetaSerializer& r, std::vector<bool, Allocator>& c)
    {
        r.template collectionItems<bool>("@itemcount");
    }
};

template<typename Container>
struct ReflectReadSetItems<MetaSerializer, Container>
{
    typedef typename Container::value_type rawtype;
    typedef typename remove_cvref<rawtype>::type type;

    static void reflect(MetaSerializer& r, Container& c)
    {
        r.template collectionItems<type>("@itemcount");
    }
};

template<typename Container>
struct ReflectReadMapItems<MetaSerializer, Container>
{
    typedef typename Container::key_type rawkeytype;
    typedef typename Container::mapped_type rawmappedtype;
    typedef typename std::pair<typename remove_cvref<rawkeytype>::type,
                               typename remove_cvref<rawmappedtype>::type> type;

    static void reflect(MetaSerializer& r, Container& c)
    {
        r.template collectionItems<type>("@itemcount");
    }
};


} // namespace



} // namespace

#endif