AbstractReflector.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_ABSTRACTREFLECTOR_H_
#define _MIRA_ABSTRACTREFLECTOR_H_

#include <serialization/ReflectorInterface.h>
#include <utils/HasMember.h>
#include <utils/HasNonMember.h>

namespace mira {



namespace detail {
template<class Type>
struct ____MISSING_REFLECT_METHOD_FOR_{
    static_assert(sizeof(Type)==0,
        "Cannot find an (unambiguous) intrusive or nonintrusive reflect method for Type. "
        "If Type is a class that you have implemented, then you should "
        "implement its reflect() method. If Type is a common class or "
        "container from an external library (including std, boost, etc.), you "
        "probably need to include an adapter header "
        "like #include <serialization/adapters/std/vector>. \nNote: "
        "If you are sure a matching reflect() method exists, it might be ambiguous. "
        "Define MIRA_SERIALIZATION_DISABLE_DETECT_REFLECT to skip MIRA's compile-time check "
        "and see all candidates considered "
        "(warning: will probably result in much more messy error message).");
    static void invoke() {}
};
} // namespace

namespace serialization {


// create detectors for reflect methods
MIRA_MEMBER_DETECTOR(reflect);
MIRA_NONMEMBER_FUNCTION2_DETECTOR(void, reflect);


} // namespace

template <typename Derived>
class AbstractReflector : public ReflectorInterface<Derived>
{

public:

    using VersionType = typename ReflectorInterface<Derived>::VersionType;

public:

    template <typename T>
    VersionType requireVersion(VersionType version, VersionType minVersion, const T* caller = NULL) {
        VersionType v = This()->template version<T>(version);
        checkVersion<T>(v, minVersion, false);
        return v;
    }

    MIRA_DEPRECATED("Please call as requireVersion<MyType>(v, minV) or requireVersion(v, minV, this)",
    VersionType requireVersion(VersionType version, VersionType minVersion)) {
        VersionType v = This()->version(version);
        checkVersion(v, minVersion);
        return v;
    }

    template <typename T>
    void requireVersion(VersionType requiredVersion, const T* caller = NULL) {
        requireVersion<T>(requiredVersion, requiredVersion);
    }

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

    using AcceptDesiredVersion = typename ReflectorInterface<Derived>::AcceptDesiredVersion;

    template <typename T>
    VersionType requireVersion(VersionType version, VersionType minVersion,
                               AcceptDesiredVersion, const T* caller = NULL) {
        VersionType v = This()->template version<T>(version, AcceptDesiredVersion());
        checkVersion<T>(v, minVersion, true);
        return v;
    }

    template <typename T>
    void requireVersion(VersionType requiredVersion, AcceptDesiredVersion, const T* caller = NULL) {
        requireVersion<T>(requiredVersion, requiredVersion, AcceptDesiredVersion());
    }

private:

    template <typename T>
    void checkVersion(VersionType version, VersionType minVersion, bool potentiallyDesired = false) {
        if(version < minVersion)
            MIRA_THROW(XIO, (potentiallyDesired ? "Found or desired " : "Found ") <<
                            "version for type '" << typeName<T>() <<
                            "': " << (int)version << ", but require "
                            "at least version: " << (int)minVersion);
    }

    void checkVersion(VersionType version, VersionType minVersion) {
        if(version < minVersion)
            MIRA_THROW(XIO, "Found version: " << (int)version <<
                            ", but require at least version: " << (int)minVersion);
    }

public:

    template <typename Base>
    void reflectBase(Base& base) {
        this->invoke(base);
    }

protected:

    Derived* This()
    {
        // the Derived was derived from us, so we can safely cast to it ...
        return static_cast<Derived*>(this);
    }

    template<typename T>
    void invoke(T& object)
    {
        this->This()->invokeOverwrite(object);
    }

    template<typename T>
    void invokeOverwrite(T& object)
    {
        using namespace serialization;

        typedef MIRA_HAS_MEMBER_TEMPLATE(T, reflect) hasMemberReflect;
#ifdef MIRA_SERIALIZATION_DISABLE_DETECT_REFLECT
        typedef std::true_type hasNonMemberReflect;
#else
        typedef MIRA_HAS_NONMEMBER_FUNCTION2(reflect, Derived&, typename boost::remove_const<T>::type&) hasNonMemberReflect;
#endif
        if constexpr (hasMemberReflect::value) {
            reflectComplexIntrusive(object);
        }
        else if constexpr (hasNonMemberReflect::value) {
            reflectComplexNonintrusive(object);
        }
        else {
            reflectMissing(object);
        }
    }

    template<typename T>
    void reflectComplexIntrusive(T& object)
    {
        typedef typename boost::remove_const<T>::type TwithoutConst;
        auto& nonconstObject = const_cast<TwithoutConst&>(object);
        nonconstObject.reflect(*(this->This()));
    }

    template<typename T>
    void reflectComplexNonintrusive(T& object)
    {
        // #################################################################
        // If you get a compiler error here, you do not have specified a
        // proper non-intrusive reflect method for the type T. You can
        // either provide an intrusive or non-intrusive reflect method.
        // #################################################################
        typedef typename boost::remove_const<T>::type TwithoutConst;
        reflect(*(this->This()), const_cast<TwithoutConst&>(object));
    }

    template<typename T>
    void reflectMissing(T& object)
    {
        typedef typename boost::remove_const<T>::type TwithoutConst;
        mira::detail::____MISSING_REFLECT_METHOD_FOR_<TwithoutConst>::invoke();
    }
};


} // namespace

#endif // _MIRA_ABSTRACTREFLECTOR_H_