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>

#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 {


class OneWaySwitch
{
public:
    [[nodiscard]] bool query() const
    {
        return isOn;
    }

    void set()
    {
        isOn = true;
    }

private:
    bool isOn = false;
};

template<typename T, typename Reflector>
static OneWaySwitch& reflectedAsPointer()
{
    static OneWaySwitch value{};
    return value;
}

template<typename T, typename Reflector>
struct SetReflectedAsPointer
{
    SetReflectedAsPointer()
    {
        reflectedAsPointer<T, Reflector>().set();
    }
};


// Helper to analyze if typename DelegateTo is defined in DelegatingType
template<typename DelegatingType, typename = void>
struct HasDelegateTo : std::false_type {
};

template<typename DelegatingType>
struct HasDelegateTo<DelegatingType, std::void_t<typename DelegatingType::DelegateTo>> : std::true_type {};

template<typename DelegatingType, typename SerializerTag>
struct TransparentMissingDelegateTo
{
    MIRA_DEPRECATED("Please define (public!) type DelegateTo in specialization of IsTransparentSerializable<DelegatingType, SerializerTag> "
                    "to enable properly detecting the possibility of child members/properties",
    static constexpr void warn(){}
    )
};

template<typename T, typename SerializerTag = void>
constexpr bool hasRecursiveReflect()
{
    if constexpr (IsAtomicSerializable<T>::value)
        return false;
    if constexpr (std::is_enum_v<T>)
        return false;

    using TransparentTrait = IsTransparentSerializable<T, SerializerTag>;

    if constexpr (TransparentTrait::value) {
        if constexpr(HasDelegateTo<TransparentTrait>::value) {
            return hasRecursiveReflect<typename TransparentTrait::DelegateTo, SerializerTag>();
        } else
            TransparentMissingDelegateTo<T, SerializerTag>::warn();
    }

    return 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) {}

    void raise(bool recursive = false) override
    {
        // The exception object is copy-initialized from *this.
        throw *this;
    }
};


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

    RecursiveMemberReflectorBase() :
        mCurrentMemberMeta(nullptr) {}

protected:

    static constexpr auto MIRA_REFLECTOR_TOPLEVEL_NAME = "@value";

public:


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

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

        if constexpr (std::is_base_of_v<mira::Object, T>) {
            reflectPointerPolymorphic(pointer);
        }
        else if constexpr (std::is_abstract_v<T>) {
            reflectPointerAbstract(pointer);
        }
        else {
            reflectPointerNormal(pointer);
        }
    }

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

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

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

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

                // deserialize the content recursively
                r.invoke(*this->This(), serialization::void_upcast(pointer));
            }
            catch (XPolymorphicPointerReflectorNotRegistered&) {
                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>()
                               << "'"
#ifndef MIRA_REGISTER_LEGACY_SERIALIZERS
                               << " (Registration with legacy serializers must be explicitly enabled"
                                  " by activating the option REGISTER_LEGACY_SERIALIZERS"
                                  " [GlobalConfig, requires recompilation])";
#endif
                );
            }
        }
    }

    template<typename T>
    void pointerAbstract(T*& pointer, int typeId)
    {
        if (pointer != nullptr) // 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:

    [[nodiscard]] const ReflectMemberMeta& getCurrentMemberMeta() const
    {
        assert(mCurrentMemberMeta!=nullptr);
        return *mCurrentMemberMeta;
    }

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

public:

    template<typename T>
    static bool isReflectedAsPointer()
    {
        return serialization::reflectedAsPointer<T, Derived>().query();
    }

protected:
    template<typename T>
    void invokeTrackObject(T& member)
    {
        if constexpr (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.

    template<typename T>
    void reflectUnknown(T& member)
    {
        static_assert(sizeof(T) == 0, "Trying to reflect unknown type.");
    }

    template<typename T>
    void reflectAtomic(T& member)
    {
        this->This()->invokeTrackObject(member);
        this->This()->atomic(member);
    }

    template<typename T>
    void reflectEnumeration(T& member)
    {
        this->This()->invokeTrackObject(member);
        this->This()->enumeration(member);
    }

    template<typename T>
    void reflectArray(T& member)
    {
        this->This()->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);
        reflectCollection(array);
    }

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

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

    template<typename T>
    void reflectPointer(T& member)
    {
        this->This()->pointer(member);
    }

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

    template<typename T>
    void reflectPointerNormal(T*& member)
    {
        this->This()->pointerNormal(member, typeId<T>());
    }

    template<typename T>
    void reflectPointerPolymorphic(T*& member)
    {
        int typeId = -1;

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

        // call pointerPolymorphic()
        this->This()->pointerPolymorphic(member, typeId);
    }

    template<typename T>
    void reflectPointerAbstract(T*& member)
    {
        this->This()->pointerAbstract(member, typeId<T>());
    }

    template<typename T>
    void chooseReflect(T& member)
    {
        using Type = typename std::remove_cv<T>::type;
        if constexpr (std::is_pointer_v<Type>) {
            reflectPointer(member);
        } // T is a pointer (Type C)
        else if constexpr (IsAtomicSerializable<Type>::value) {
            reflectAtomic(member);
        } // atomic (Type A1)
        else if constexpr (std::is_class_v<Type>) {
            if constexpr (IsCollection<Type>::value) {
                reflectCollection(member);
            } // T is a collection (Type B?c)
            else {
                reflectComplex(member);
            } // T is a complex class (Type B1/B2)
        }
        else if constexpr (std::is_enum_v<Type>) {
            reflectEnumeration(member);
        } // enum (Type A2)
        else if constexpr (std::is_array_v<Type>) {
            reflectArray(member);
        } // T is no pointer, no class --> must be atomic or enum
        else {
            reflectUnknown(member);
        }
    }

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==nullptr)
                    MIRA_THROW(XLogical, "Top-level member cannot be 'inline'. "
                        "It must have an ID != NULL!");
                mCurrentMemberFullID=meta.id;
            } else if(meta.id!=nullptr)
                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 != nullptr)
            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(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(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 constexpr(!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(nullptr, nullptr, "") );
            this->This()->popObjectTrackingStore();
        } else
            this->invokeMember(member, ReflectMemberMeta(nullptr, nullptr, "") );
    }

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

};


}

#endif