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_

#ifndef Q_MOC_RUN
#include <boost/type_traits/remove_const.hpp>
#include <boost/mpl/assert.hpp>
#endif

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

    typedef typename ReflectorInterface<Derived>::VersionType 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);
    }

    typedef typename ReflectorInterface<Derived>::AcceptDesiredVersion 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
        typedef typename
                boost::mpl::eval_if<hasMemberReflect,
                    boost::mpl::identity< ReflectComplexIntrusive >,   // T is a class with reflect method (Type B1)
                    //else
                    boost::mpl::eval_if<hasNonMemberReflect,
                        boost::mpl::identity< ReflectComplexNonintrusive >, // T is a class without reflect method (Type B2)
                        // else
                        boost::mpl::identity< ReflectMissing >
                    >
                >::type chosen_reflect;

        chosen_reflect::invoke(*this->This(), object);
    }

    struct ReflectComplexIntrusive {
        template<typename T>
        static void invoke(Derived& r, T& object) {
            typedef typename boost::remove_const<T>::type TwithoutConst;
            TwithoutConst& nonconstObject = const_cast<TwithoutConst&>(object);
            nonconstObject.reflect(r);
        }
    };

    struct ReflectComplexNonintrusive {
        template<typename T>
        static void invoke(Derived& r, 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(r, const_cast<TwithoutConst&>(object));
        }
    };

    struct ReflectMissing {
        template<typename T>
        static void invoke(Derived& r, T& object) {
            typedef typename boost::remove_const<T>::type TwithoutConst;
            mira::detail::____MISSING_REFLECT_METHOD_FOR_<TwithoutConst>::invoke();
        }
    };
};


} // namespace

#endif // _MIRA_ABSTRACTREFLECTOR_H_