CRNObject.h

Go to the documentation of this file.

/* Copyright 2006-2016 Yann LEYDIER, CoReNum, INSA-Lyon, ENS-Lyon
 * 
 * This file is part of libcrn.
 * 
 * libcrn is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * libcrn is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with libcrn.  If not, see <http://www.gnu.org/licenses/>.
 * 
 * file: CRNObject.h
 * \author Yann LEYDIER
 */

#ifndef CRNOBJECT_HEADER
#define CRNOBJECT_HEADER

#include <CRN.h>

namespace crn
{
    class Object;
    CRN_ALIAS_SMART_PTR(Object)
}
namespace crn
{
    class Object
    {
        public:
            virtual ~Object() = default;
        protected:
    };

    UObject Clone(const Object &obj);
    UObject Clone(const UCObject &obj);
    UObject Clone(const SCObject &obj);
    class Int;
    std::unique_ptr<Int> Clone(int i);
    class Real;
    std::unique_ptr<Real> Clone(double d);
    class Prop3;
    std::unique_ptr<Prop3> Clone(bool b);

    template<typename T, typename U> inline std::unique_ptr<T> CloneAs(const U &obj) { return std::unique_ptr<T>(dynamic_cast<T*>(Clone(obj).release())); }

    namespace xml
    {
        class Element;
    }
    void Deserialize(Object &obj, xml::Element &el);
    void Deserialize(const UObject &obj, xml::Element &el);
    void Deserialize(const SObject &obj, xml::Element &el);
    xml::Element Serialize(const Object &obj, xml::Element &parent);
    xml::Element Serialize(const UCObject &obj, xml::Element &parent);
    xml::Element Serialize(const SCObject &obj, xml::Element &parent);

    double Distance(const Object &o1, const Object &o2);
    double Distance(const UCObject &o1, const UCObject &o2);
    double Distance(const SCObject &o1, const SCObject &o2);
    // see CRNMath.h for Distance between numbers

    template<typename T> struct IsPOSet: public std::integral_constant<bool, traits::HasLT<T>::value && traits::HasGT<T>::value && traits::HasLE<T>::value && traits::HasGE<T>::value> {};

    // Metric objects
    template<typename T> struct IsMetric: public std::integral_constant<bool, std::is_arithmetic<T>::value> {};
    template<> struct IsMetric<Object>: public std::true_type {};
    template<> struct IsMetric<UObject>: public std::true_type {};
    template<> struct IsMetric<SObject>: public std::true_type {};

    template<typename T> struct IsMagma: public std::integral_constant<bool, traits::HasEquals<T>::value && traits::HasPlus<T>::value> {};

    template<typename T> struct IsGroup: public std::integral_constant<bool, IsMagma<T>::value && traits::HasMinus<T>::value> {};

    template<typename T> struct IsRing: public std::integral_constant<bool, IsGroup<T>::value && traits::HasInnerMult<T>::value> {};

    template<typename T> struct IsVectorOverR: public std::integral_constant<bool, IsGroup<T>::value && traits::HasRightOuterMult<T>::value && traits::HasLeftOuterMult<T>::value> {};

    template<typename T> struct IsAlgebra: public std::integral_constant<bool, IsRing<T>::value && IsVectorOverR<T>::value> {};

    template<typename T> struct IsField: public std::integral_constant<bool, IsAlgebra<T>::value && traits::HasDivide<T>::value> {};

    template<typename T> struct IsSerializable: public std::false_type {};
    template<> struct IsSerializable<Object>: public std::true_type {};

    template<typename T> struct IsClonable: public std::false_type {};
    template<> struct IsClonable<Object>: public std::true_type {};

    template<typename T> struct IsSavable: public std::false_type {};
}

#define CRN_SERIALIZATION_CONSTRUCTOR(classname) public: classname(crn::xml::Element &el) { Deserialize(el); }

#define CRN_DECLARE_CLASS_CONSTRUCTOR(classname) public:\
    static void Initialize();\
private:\
struct Init { Init() { classname::Initialize(); } };\
static Init init;

#define CRN_BEGIN_CLASS_CONSTRUCTOR(classname) void classname::Initialize()\
{\
    static bool init_done = false;\
    if (!init_done)\
    {\
        init_done = true;

#define CRN_END_CLASS_CONSTRUCTOR(classname) }\
}\
classname::Init classname::init;

#endif