RecursiveMemberReflector.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_RECURSIVEMEMBERREFLECTOR_H_
#define _MIRA_RECURSIVEMEMBERREFLECTOR_H_

#include <type_traits>

#ifndef Q_MOC_RUN
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/identity.hpp>
#endif

#include <error/LoggingCore.h>

#include <factory/Factory.h>

#include <serialization/Accessor.h>

#include <serialization/ReflectMemberMeta.h>
#include <serialization/AbstractReflector.h>
#include <serialization/PolymorphicPointerReflector.h>

#include <serialization/Array.h>

#include <serialization/IsAtomicSerializable.h>
#include <serialization/IsObjectTrackable.h>
#include <serialization/IsCollection.h>
#include <serialization/IsTransparentSerializable.h>

#include <serialization/IgnoreMissing.h>

#include <serialization/VoidCast.h>

#include <utils/Singleton.h>
#include <utils/ToString.h>

namespace mira {


namespace serialization {


template <typename T, typename Reflector>
struct ReflectedAsPointer {
    ReflectedAsPointer() : value(false) {}
    bool value;
};

template <typename T, typename Reflector>
struct SetReflectedAsPointer {
    SetReflectedAsPointer() {
        LazySingleton<ReflectedAsPointer<T,Reflector>>::instance().value = true;
    }
};


} // namespace

MIRA_DEFINE_SERIALIZABLE_EXCEPTION(XMemberNotFound, XIO)


class XMemberNotFound_NoDefault : public XMemberNotFound
{
    MIRA_OBJECT(XMemberNotFound_NoDefault)
protected:
    friend class ClassFactoryDefaultConstClassBuilder;
    XMemberNotFound_NoDefault() MIRA_NOEXCEPT_OR_NOTHROW {}

public:
    XMemberNotFound_NoDefault(XMemberNotFound& ex) MIRA_NOEXCEPT_OR_NOTHROW :
        XMemberNotFound(ex) {}

    virtual void raise(bool recursive = false) { throw *this; }
};


template <typename Derived>
class RecursiveMemberReflectorBase : public AbstractReflector<Derived>
{
    typedef AbstractReflector<Derived> Base;
public:

    RecursiveMemberReflectorBase() :
        mCurrentMemberMeta(NULL) {}

protected:

    static constexpr auto MIRA_REFLECTOR_TOPLEVEL_NAME = "@value";

public:


    template<typename T>
    void atomic(T& member) {}

    template<typename T>
    void enumeration(T& member) {
        int32 val;
        if(Derived::isReadOnly::value) {
            val = static_cast<int32>(member);
            this->This()->atomic(val);
        } else {
            this->This()->atomic(val);
            member = static_cast<T>(val);
        }
    }

    template<typename T>
    void object(T& member) {
        this->This()->invoke(member); // invoke us recursively on the object
    }

    template<typename T>
    void collection(T& member) {
        this->This()->object(member); // default impl calls object()
    }


    template<typename T>
    void trackObject(T& member) {}

    template<typename T>
    void pointer(T* &pointer) {
        // this will instantiate the SetReflectedAsPointer during startup
        // which will set ReflectedAsPointer<T,Derived>::value to true,
        // and mark that T was reflected as pointer by Derived at least once.
        Singleton<serialization::SetReflectedAsPointer<T,Derived>,singleton::EagerInstantiation,singleton::CreateStatic>::instance();

        // Selects the correct pointer ReflectPointerXXX struct using boost::mpl.
        typedef typename
        boost::mpl::eval_if<std::is_base_of<mira::Object, T>,
            boost::mpl::identity< ReflectPointerPolymorphic >,   // T is a polymorphic class derived from Object
        //else
            boost::mpl::eval_if<std::is_abstract<T>,
                boost::mpl::identity< ReflectPointerAbstract >,  // T is abstract
            //else
                boost::mpl::identity< ReflectPointerNormal >     // T is a "normal" class (maybe polymorphic but not derived from Object)
            >
        >::type type;

        type::invoke(*this->This(), pointer);
    }

    template<typename T>
    void pointerNormal(T* &pointer, int typeId) {
        if(pointer!=NULL) // delegate serialization of the actual object recursively
            this->This()->invokePointerObject(*pointer);
    }

    template<typename T>
    void pointerPolymorphic(T* &pointer, int typeId) {
        if(pointer!=NULL) { // delegate serialization of the actual object recursively

            // obtain a special polymorph pointer serializer for the derived type
            typedef serialization::PolymorphicPointerReflectorRegistrar<Derived> OurRegistrar;

            typename OurRegistrar::ReflectorPtr r  =
                     OurRegistrar::instance().getPolymorphicPointerReflector(typeId);

            if(r==NULL) {
                const ReflectMemberMeta& meta = getCurrentMemberMeta();
                const Class& c = pointer->getClass();
                MIRA_THROW(XIO, "Cannot reflect the polymorphic member pointer '"
                          << meta.name << "'. The class '" << c.getIdentifier()
                          << "' was not registered with this serializer '"
                          << typeName<Derived>());
            }

            // deserialize the content recursively
            r->invoke(*this->This(), serialization::void_upcast(pointer));
        }
    }

    template<typename T>
    void pointerAbstract(T* &pointer, int typeId) {
        if(pointer!=NULL) // delegate serialization of the actual object recursively
            this->This()->invokePointerObject(*pointer);
    }


public:

    template<typename T>
    static void registerClass()
    {
        typedef serialization::PolymorphicPointerReflectorRegistrar<Derived> OurRegistrar;

        if(!OurRegistrar::isDestroyed())
            OurRegistrar::instance().template registerClass<T>();
    }

    template<typename T>
    static void unregisterClass()
    {
        typedef serialization::PolymorphicPointerReflectorRegistrar<Derived> OurRegistrar;
        if(!OurRegistrar::isDestroyed())
            OurRegistrar::instance().template unregisterClass<T>();
    }
public:

    const ReflectMemberMeta& getCurrentMemberMeta() const
    {
        assert(mCurrentMemberMeta!=NULL);
        return *mCurrentMemberMeta;
    }

    const std::string& getCurrentMemberFullID() const
    {
        assert(this->usesHumanReadableIDs());
        return mCurrentMemberFullID;
    }

public:

    template <typename T>
    static bool isReflectedAsPointer() {
        return LazySingleton<serialization::ReflectedAsPointer<T,Derived>>::instance().value;
    }

protected:

    template<typename T>
    void invokeTrackObject(T& member)
    {
        if(IsObjectTrackable<T>::value)
            this->This()->trackObject(member);
    }


    // The following structs implement different invoke methods for each of
    // the member types (A1-3, B1-2, C). The member types are detected in
    // the invoke method above which delegates to the invoke method
    // of the correct struct below.

    struct ReflectUnknown {
        template<typename T>
        static void invoke(Derived& r, T& member) {
            static_assert(sizeof(T)==0, "Trying to reflect unknown type.");
        }
    };

    struct ReflectAtomic {
        template<typename T>
        static void invoke(Derived& r, T& member) {
            r.invokeTrackObject(member);
            r.atomic(member);
        }
    };

    struct ReflectEnumeration {
        template<typename T>
        static void invoke(Derived& r, T& member) {
            r.invokeTrackObject(member);
            r.enumeration(member);
        }
    };

    struct ReflectArray {
        template<typename T>
        static void invoke(Derived& r, T& member) {
            r.invokeTrackObject(member);
            std::size_t size = sizeof(member) /
                    (static_cast<const char *>(static_cast<const void *>(&member[1]))
                    - static_cast<const char *>(static_cast<const void *>(&member[0])) );

            typedef typename std::remove_extent<T>::type ItemType;
            serialization::Array<ItemType> array(member, size);
            //r.collection(array);
            ReflectCollection::invoke(r, array);
        }
    };

    struct ReflectComplex {
        template<typename T>
        static void invoke(Derived& r, T& member) {
            r.invokeTrackObject(member);
            typedef typename std::remove_cv<T>::type Type;
            static_assert(!IsCollection<Type>::value,
                          "Trying to call ReflectComplex::invoke<T>() with IsCollection<T> == true - something is wrong.");
            if(IsTransparentSerializableHelper<Type,Derived>::value)
                r.invoke(member);
            else
                r.object(member);
        }
    };

    struct ReflectCollection {
        template<typename T>
        static void invoke(Derived& r, T& member) {
            r.invokeTrackObject(member);
            typedef typename std::remove_cv<T>::type Type;
            typedef IsTransparentSerializableHelper<Type,Derived> isTransparent;
            static_assert(!isTransparent::value,
                          "Trying to call ReflectCollection::invoke<T>() with IsTransparentSerializable<T> == true - something is wrong.");
            r.collection(member);
        }
    };

    struct ReflectPointer {
        template<typename T>
        static void invoke(Derived& r, T& member) {
            // clear the inline flag
            r.pointer(member);
        }
    };

    // The following ReflectPointerXXX structs are used by our pointer() method

    struct ReflectPointerNormal {
        template<typename T>
        static void invoke(Derived& r, T* &pointer) {
            r.pointerNormal(pointer, typeId<T>());
        }
    };


    struct ReflectPointerPolymorphic {
        template<typename T>
        static void invoke(Derived& r, T* &pointer) {
            int typeId = -1;

            if(pointer!=NULL) {
                // we have an object, so we can obtain its class information
                const Class& c = pointer->getClass();
                typeId = c.getTypeId();
            }

            // call pointerPolymorphic()
            r.pointerPolymorphic(pointer, typeId);
        }
    };

    struct ReflectPointerAbstract {
        template<typename T>
        static void invoke(Derived& r, T* &pointer) {
            r.pointerAbstract(pointer, typeId<T>());
        }
    };


    template<typename T>
    struct ChooseReflect {

        typedef typename std::remove_cv<T>::type Type;
        typedef typename
            boost::mpl::eval_if<std::is_pointer<Type>,
                boost::mpl::identity<ReflectPointer>, // T is a pointer (Type C)
            //else
                boost::mpl::eval_if<IsAtomicSerializable<Type>,
                    boost::mpl::identity<ReflectAtomic>,       // atomic (Type A1)
                // else // T is not atomic
                    boost::mpl::eval_if<std::is_class<Type>,
                        boost::mpl::eval_if<IsCollection<Type>,
                            boost::mpl::identity<ReflectCollection>,  // T is a collection (Type B?c)
                        // else
                            boost::mpl::identity<ReflectComplex>>,    // T is a complex class (Type B1/B2)
                    //else // T is no pointer, no class --> must be atomic or enum
                        boost::mpl::eval_if<std::is_enum<Type>,
                            boost::mpl::identity<ReflectEnumeration>,     // enum (Type A2)
                        // else
                            boost::mpl::eval_if<std::is_array<Type>,
                                boost::mpl::identity<ReflectArray>,       // array (Type A3)
                            // ELSE unknown
                                boost::mpl::identity<ReflectUnknown>
                        >
                    >
                >
            >
        >::type type;
    };

public:

    template<typename T>
    void invokeMember(T& member, const ReflectMemberMeta& meta)
    {
        this->This()->invokeMemberOverwrite(member, meta);
    }

    template<typename T>
    void invokeMemberOverwrite(T& member, const ReflectMemberMeta& meta)
    {
        // store previous meta (it is restored at the end of this method
        // and therefore implements a stack, where mCurrentMemberMeta is
        // the top element in the stack)
        const ReflectMemberMeta* prevMeta = mCurrentMemberMeta;

        // do the same to create a stack of the full human readable object
        // id (however, only do it, if our final reflector supports human
        // readable id's, otherwise skip this step since it hurts the
        // performance
        std::string prevFullID;
        if(this->usesHumanReadableIDs()) {
            prevFullID = mCurrentMemberFullID;

            // "push" new full id
            if(mCurrentMemberFullID.empty()) {
                if(meta.id==NULL)
                    MIRA_THROW(XLogical, "Top-level member cannot be 'inline'. "
                        "It must have an ID != NULL!");
                mCurrentMemberFullID=meta.id;
            } else if(meta.id!=NULL)
                mCurrentMemberFullID = mCurrentMemberFullID + "." + meta.id;
        }

        // "push" current meta (but only if member is not transparent, which is
        // indicated by an id of NULL)
        if(meta.id != NULL)
            mCurrentMemberMeta = &meta;

        // Choose the type of the member and select the
        // correct ReflectXYZ struct for that type at compile type.
        // Then call the invoke method of that struct.
        // (The different structures and their invoke methods are defined
        // above)
        try
        {
            ChooseReflect<T>::type::invoke(*this->This(), member);
        }
        catch(...)
        {
            // "pop" our id
            if(this->usesHumanReadableIDs())
                mCurrentMemberFullID=prevFullID;
            // "pop" our meta data stack.
            mCurrentMemberMeta = prevMeta;
            // and throw
            throw;
        }

        // "pop" our id
        if(this->usesHumanReadableIDs())
            mCurrentMemberFullID=prevFullID;
        // "pop" our meta data stack.
        mCurrentMemberMeta = prevMeta;
    }

    template<typename T>
    void invokePointerObject(T& member)
    {
        ChooseReflect<T>::type::invoke(*this->This(), member);
    }


    template<typename T>
    void invokeMemberWithoutDefault(T& member, const ReflectMemberMeta& meta)
    {
        try {
            this->invokeMember(member,meta);
        } catch (XMemberNotFound& ex) {
            throw XMemberNotFound_NoDefault(ex);
            // transform exception to avoid catching it
            // in upper levels, where it might be shadowed
            // if a default value is given there (see #685)
        } catch(Exception& ex) {
            if (meta.getName() == MIRA_REFLECTOR_TOPLEVEL_NAME) // no extra info
                throw;

            MIRA_RETHROW(ex, "while " <<
                         (Derived::isReadOnly::value ? "serializing" : "deserializing") <<
                         " '" << meta.getName() << "'");
        }
    }

    template<typename T, typename U>
    void invokeMemberWithDefault(T& member, const ReflectMemberMeta& meta,
                                 const U& defaultValue)
    {
        try {
            this->invokeMember(member,meta);
        } catch (XMemberNotFound_NoDefault&) {
            throw; // must not handle this
        } catch (XMemberNotFound&) {
            if(!Derived::isReadOnly::value) {
                MIRA_LOG(NOTICE) << "No value given for '" << meta.name << "', "
                    "using the default value instead.";

                // #############################################################
                // If you get a compiler error here, your default value does not
                // match to your member type and cannot be casted. Make sure
                // that the data type of your default value can be casted to
                // the data type of your member!
                // #############################################################
                try {
                    member=defaultValue;
                } catch(Exception& ex) {
                    MIRA_RETHROW(ex, "while default-initializing '" << meta.getName() << "'");
                }
            }
        } catch(Exception& ex) {
            if (meta.getName() == MIRA_REFLECTOR_TOPLEVEL_NAME) // no extra info
                throw;

            MIRA_RETHROW(ex, "while " <<
                         (Derived::isReadOnly::value ? "serializing" : "deserializing") <<
                         " '" << meta.getName() << "'");
        }
    }

    template<typename T>
    void invokeMemberWithDefault(T& member, const ReflectMemberMeta& meta,
                                 const serialization::IgnoreMissing& defaultValue)
    {
        try {
            this->invokeMember(member,meta);
        } catch (XMemberNotFound_NoDefault&) {
            throw; // must not handle this
        } catch (XMemberNotFound&) {
            // IGNORE
        } catch(Exception& ex) {
            if (meta.getName() == MIRA_REFLECTOR_TOPLEVEL_NAME) // no extra info
                throw;

            MIRA_RETHROW(ex, "while " <<
                         (Derived::isReadOnly::value ? "serializing" : "deserializing") <<
                         " '" << meta.getName() << "'");
        }
    }


private:

    const ReflectMemberMeta* mCurrentMemberMeta;
    std::string mCurrentMemberFullID;

};


template <typename Derived>
class RecursiveMemberReflector : public RecursiveMemberReflectorBase<Derived>
{
public:

    // implement our supported visiting methods of the ReflectorInterface
    // note: the documentation of the following methods is inherited from
    // ReflectorInterface by Doxygen

    template<typename T>
    void member(const char* name, T& member, const char* comment,
                ReflectCtrlFlags flags = REFLECT_CTRLFLAG_NONE) {
        if (flags & REFLECT_CTRLFLAG_TEMP_TRACKING) {
            this->This()->pushObjectTrackingStore();
            this->invokeMemberWithoutDefault(member, ReflectMemberMeta(name, name, comment) );
            this->This()->popObjectTrackingStore();
        } else
            this->invokeMemberWithoutDefault(member, ReflectMemberMeta(name, name, comment) );
    }

    template<typename T>
    void member(const char* name, const std::string& id, T& member,
                const char* comment, ReflectCtrlFlags flags = REFLECT_CTRLFLAG_NONE) {
        if (flags & REFLECT_CTRLFLAG_TEMP_TRACKING) {
            this->This()->pushObjectTrackingStore();
            this->invokeMemberWithoutDefault(member, ReflectMemberMeta(name, id.c_str(),
                                             comment) );
            this->This()->popObjectTrackingStore();
        } else
            this->invokeMemberWithoutDefault(member, ReflectMemberMeta(name, id.c_str(),
                                             comment) );
    }

    template<typename T>
    void member(const char* name, const T& member, Setter<T> setter,
                const char* comment, ReflectCtrlFlags flags = REFLECT_CTRLFLAG_NONE) {
        auto a = makeAccessor(member, setter);
        this->This()->pushObjectTrackingStore();
        this->invokeMemberWithoutDefault(a, ReflectMemberMeta(name, name, comment) );
        this->This()->popObjectTrackingStore();
    }

    template<typename T>
    void member(const char* name, Getter<T> getter, Setter<T> setter,
                const char* comment, ReflectCtrlFlags flags = REFLECT_CTRLFLAG_NONE) {
        auto a = makeAccessor(getter, setter);
        this->This()->pushObjectTrackingStore();
        this->invokeMemberWithoutDefault(a, ReflectMemberMeta(name, name, comment) );
        this->This()->popObjectTrackingStore();
    }

    // avoid member("MyMember", member, "my member", {}) (most probably meant to
    // set default-initialized object as deserialization default) unambiguously matching
    // Reflector::member(name, member, comment, flags). see #910
    template<typename T>
    void member(const char* name, T& member, const char* comment,
                const T& defaultValue, ReflectCtrlFlags flags = REFLECT_CTRLFLAG_NONE) {
        this->template member<T, T>(name, member, comment, defaultValue, flags);
    }

    template<typename T, typename U>
    void member(const char* name, T& member, const char* comment,
                const U& defaultValue, ReflectCtrlFlags flags = REFLECT_CTRLFLAG_NONE) {
        if (flags & REFLECT_CTRLFLAG_TEMP_TRACKING) {
            this->This()->pushObjectTrackingStore();
            this->invokeMemberWithDefault(member, ReflectMemberMeta(name, name, comment),
                                          defaultValue);
            this->This()->popObjectTrackingStore();
        } else
            this->invokeMemberWithDefault(member, ReflectMemberMeta(name, name, comment),
                                          defaultValue);
    }

    // see above. see #910
    template<typename T>
    void member(const char* name, const T& member, Setter<T> setter,
                const char* comment, const T& defaultValue,
                ReflectCtrlFlags flags = REFLECT_CTRLFLAG_NONE) {
        this->template member<T, T>(name, member, setter, comment, defaultValue, flags);
    }

    template<typename T, typename U>
    void member(const char* name, const T& member, Setter<T> setter,
                const char* comment, const U& defaultValue,
                ReflectCtrlFlags flags = REFLECT_CTRLFLAG_NONE) {
        auto a = makeAccessor(member, setter);
        this->This()->pushObjectTrackingStore();
        this->invokeMemberWithDefault(a, ReflectMemberMeta(name, name, comment),
                                      defaultValue );
        this->This()->popObjectTrackingStore();
    }

    // see above. see #910
    template<typename T>
    void member(const char* name, Getter<T> getter, Setter<T> setter,
                const char* comment, const T& defaultValue,
                ReflectCtrlFlags flags = REFLECT_CTRLFLAG_NONE) {
        this->template member<T, T>(name, getter, setter, comment, defaultValue, flags);
    }

    template<typename T, typename U>
    void member(const char* name, Getter<T> getter, Setter<T> setter,
                const char* comment, const U& defaultValue,
                ReflectCtrlFlags flags = REFLECT_CTRLFLAG_NONE) {
        auto a = makeAccessor(getter, setter);
        this->This()->pushObjectTrackingStore();
        this->invokeMemberWithDefault(a, ReflectMemberMeta(name, name, comment),
                                      defaultValue );
        this->This()->popObjectTrackingStore();
    }

    template<typename T>
    void property(const char* name, T& member, const char* comment,
                  PropertyHint&& hint = PropertyHint(),
                  ReflectCtrlFlags flags = REFLECT_CTRLFLAG_NONE) {
        if (flags & REFLECT_CTRLFLAG_TEMP_TRACKING) {
            this->This()->pushObjectTrackingStore();
            this->invokeMemberWithoutDefault(member, ReflectMemberMeta(name, name, comment) );
            this->This()->popObjectTrackingStore();
        } else
            this->invokeMemberWithoutDefault(member, ReflectMemberMeta(name, name, comment) );
    }

    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) {
        if (flags & REFLECT_CTRLFLAG_TEMP_TRACKING) {
            this->This()->pushObjectTrackingStore();
            this->invokeMemberWithoutDefault(member, ReflectMemberMeta(name, id.c_str(), comment) );
            this->This()->popObjectTrackingStore();
        } else
            this->invokeMemberWithoutDefault(member, ReflectMemberMeta(name, id.c_str(), comment) );
    }

    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) {
        auto a = makeAccessor(member, setter);
        this->This()->pushObjectTrackingStore();
        this->invokeMemberWithoutDefault(a, ReflectMemberMeta(name, name, comment) );
        this->This()->popObjectTrackingStore();
    }

    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) {
        auto a = makeAccessor(getter, setter);
        this->This()->pushObjectTrackingStore();
        this->invokeMemberWithoutDefault(a, ReflectMemberMeta(name, name, comment) );
        this->This()->popObjectTrackingStore();
    }

    // see above. see #910
    template<typename T>
    void property(const char* name, T& member, const char* comment,
                  const T& defaultValue, PropertyHint&& hint = PropertyHint(),
                  ReflectCtrlFlags flags = REFLECT_CTRLFLAG_NONE) {
        this->template property<T, T>(name, member, comment, defaultValue, std::move(hint), flags);
    }

    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) {
        if (flags & REFLECT_CTRLFLAG_TEMP_TRACKING) {
            this->This()->pushObjectTrackingStore();
            this->invokeMemberWithDefault(member, ReflectMemberMeta(name, name, comment),
                                          defaultValue);
            this->This()->popObjectTrackingStore();
        } else
            this->invokeMemberWithDefault(member, ReflectMemberMeta(name, name, comment),
                                          defaultValue);
    }

    // see above. see #910
    template<typename T>
    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) {
        this->template property<T, T>(name, member, setter, comment, defaultValue, std::move(hint), flags);
    }

    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) {
        auto a = makeAccessor(member, setter);
        this->This()->pushObjectTrackingStore();
        this->invokeMemberWithDefault(a, ReflectMemberMeta(name, name, comment),
                                      defaultValue );
        this->This()->popObjectTrackingStore();
    }

    // see above. see #910
    template<typename T>
    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) {
        this->template property<T, T>(name, getter, setter, comment, defaultValue, std::move(hint), flags);
    }

    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) {
        auto a = makeAccessor(getter, setter);
        this->This()->pushObjectTrackingStore();
        this->invokeMemberWithDefault(a, ReflectMemberMeta(name, name, comment),
                                      defaultValue );
        this->This()->popObjectTrackingStore();
    }

    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(NULL, NULL, "") );
            this->This()->popObjectTrackingStore();
        } else
            this->invokeMember(member, ReflectMemberMeta(NULL, NULL, "") );
    }

    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(NULL, NULL, "") );
        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(NULL, NULL, "") );
        this->This()->popObjectTrackingStore();
    }

};


}

#endif