variable.h

Go to the documentation of this file.

#pragma once
#ifndef INCLUDED_VARIABLE_H_
#define INCLUDED_VARIABLE_H_
 
//#include "warning_push.h"
//#include <torch/torch.h>
//#include <ATen/ATen.h>
//#include "warning_pop.h"
 
#include "types.h"
#include "dict.h"
#include "rational.h"
//#include "context.h"
 
namespace newlang {
 
    // Convert a wide Unicode string to an UTF8 string
 
    std::string utf8_encode(const std::wstring wstr);
 
    // Convert an UTF8 string to a wide Unicode String
 
    std::wstring utf8_decode(const std::string str);
 
    class Term;
    class Obj;
 
    typedef std::shared_ptr<Obj> ObjPtr;
    typedef std::shared_ptr<const Obj> ObjPtrConst;
    typedef std::weak_ptr<Obj> ObjWeak;
    typedef std::weak_ptr<const Obj> ObjWeakConst;
 
    typedef std::shared_ptr<Term> TermPtr;
    typedef std::shared_ptr<const Term> TermPtrConst;
    //    typedef std::weak_ptr<Term> TermWeak;
 
    enum class RefType : uint8_t {
        Value = 0, // По значению
        Shared = 1, // Без ссылок
        LiteSingle = 2, // Легкая ссылка для одного потока (без синхронизации)  &
        LiteThread = 3, // Легкая многопоточная ссылка (внешняя синхронизация with) &? 
        SyncMono = 4, // Объект синхронизации с монопольным мьютексом &&
        SyncMulti = 5, // Объект синхронизации с рекурсивным мьютексом &*
 
        SharedConst = 6,
        LiteSingleConst = 7,
        LiteThreadConst = 8,
        SyncMonoConst = 9,
        SyncMultiConst = 10,
    };
 
    inline constexpr RefType RefTypeFromString(const std::string_view text) {
        if (text.empty()) {
            return RefType::Value;
        } else if (text.compare("*") == 0) {
            return RefType::Shared;
        } else if (text.compare("*^") == 0) {
            return RefType::SharedConst;
        } else if (text.compare("&") == 0) {
            return RefType::LiteSingle;
        } else if (text.compare("&^") == 0) {
            return RefType::LiteSingleConst;
        } else if (text.compare("&?") == 0) {
            return RefType::LiteThread;
        } else if (text.compare("&?^") == 0) {
            return RefType::LiteThreadConst;
        } else if (text.compare("&*") == 0) {
            return RefType::SyncMulti;
        } else if (text.compare("&*^") == 0) {
            return RefType::SyncMultiConst;
        } else if (text.compare("&&") == 0) {
            return RefType::SyncMono;
        } else if (text.compare("&&^") == 0) {
            return RefType::SyncMonoConst;
        }
        LOG_RUNTIME("Unknown reference type '%s'!", text.begin());
    }
 
    inline constexpr bool isLiteRef(RefType type) {
        return type == RefType::LiteSingle || type == RefType::LiteSingleConst || type == RefType::LiteThread || type == RefType::LiteThreadConst;
    }
 
    inline constexpr bool isLiteSyncRef(RefType type) {
        return type == RefType::LiteThread || type == RefType::LiteThreadConst;
    }
 
    inline bool isHeavyRef(RefType type) {
        return type == RefType::SyncMono || type == RefType::SyncMonoConst || type == RefType::SyncMulti || type == RefType::SyncMultiConst;
    }
 
    inline constexpr bool isConstRef(RefType type) {
        return type == RefType::LiteSingleConst || type == RefType::LiteThreadConst || type == RefType::SyncMonoConst || type == RefType::SyncMultiConst;
    }
 
    inline constexpr bool isEditableRef(RefType type) {
        return type == RefType::LiteSingle || type == RefType::LiteThread || type == RefType::SyncMono || type == RefType::SyncMulti;
    }
 
    inline constexpr bool isValidReference(RefType type, RefType test) {
        switch (type) {
            case RefType::Value:
                return test == RefType::Value;
            case RefType::Shared:
                return test == RefType::Shared || test == RefType::SharedConst;
            case RefType::LiteSingle:
                return test == RefType::LiteSingle || test == RefType::LiteSingleConst;
            case RefType::LiteSingleConst:
                return test == RefType::LiteSingleConst;
            case RefType::LiteThread:
                return test == RefType::LiteThread || test == RefType::LiteThreadConst;
            case RefType::LiteThreadConst:
                return test == RefType::LiteThreadConst;
            case RefType::SyncMono:
                return test == RefType::SyncMono || test == RefType::SyncMonoConst;
            case RefType::SyncMonoConst:
                return test == RefType::SyncMonoConst;
            case RefType::SyncMulti:
                return test == RefType::SyncMulti || test == RefType::SyncMultiConst;
            case RefType::SyncMultiConst:
                return test == RefType::SyncMultiConst;
        }
        LOG_RUNTIME("Unknown reference type code! (%d)", static_cast<int> (type));
    }
 
    
    class Variable;
    struct VariablePair;
    typedef std::shared_ptr<Variable> VariablePtr;
 
    
    class Sync {
    protected:
        friend class VariableTaken;
 
        const RefType m_type;
        const std::thread::id m_thread_id;
        const std::chrono::milliseconds & m_timeout;
 
        mutable std::variant<std::monostate, std::shared_timed_mutex, std::recursive_timed_mutex> m_sync;
 
        std::shared_ptr<Variable> m_data; 
 
    public:
 
        static constexpr std::chrono::milliseconds SyncTimeoutDeedlock = std::chrono::milliseconds(5000);
        static constexpr std::chrono::seconds SyncWithoutWait = std::chrono::seconds(0);
 
        Sync(RefType type, const std::chrono::milliseconds & timeout_duration = SyncTimeoutDeedlock) :
        m_type(type), m_thread_id(std::this_thread::get_id()), m_timeout(timeout_duration), m_sync(std::monostate()), m_data(nullptr) {
            ASSERT(m_type != RefType::Value);
            if (type == RefType::LiteSingle || type == RefType::LiteSingleConst || type == RefType::LiteThread || type == RefType::LiteThreadConst) {
                ASSERT(std::holds_alternative<std::monostate>(m_sync));
            } else if (type == RefType::SyncMono || type == RefType::SyncMonoConst) {
                m_sync.emplace<std::shared_timed_mutex>();
            } else if (type == RefType::SyncMulti || type == RefType::SyncMultiConst) {
                m_sync.emplace<std::recursive_timed_mutex>();
            } else {
                LOG_RUNTIME("Unknown synchronization type! (%d)", static_cast<int> (type));
            }
        }
 
        static std::shared_ptr<Sync> CreateSync(const TermPtr &term);
        static std::shared_ptr<Sync> CreateSync(const std::string_view ref);
 
        inline RefType GetRefType() const {
            return m_type;
        }
 
        inline std::thread::id GetThreadId() const {
            return m_thread_id;
        }
 
        inline bool SyncLock(bool edit_mode = true, const std::chrono::milliseconds & timeout_duration = Sync::SyncTimeoutDeedlock) {
            if (m_type == RefType::LiteSingle || m_type == RefType::LiteSingleConst) {
                if (m_thread_id != std::this_thread::get_id()) {
                    LOG_RUNTIME("Calling a function on another thread!");
                }
            } else if (m_type == RefType::SyncMono || m_type == RefType::SyncMonoConst) {
                ASSERT(std::holds_alternative<std::shared_timed_mutex>(m_sync));
                if (edit_mode) {
                    return std::get<std::shared_timed_mutex>(m_sync).try_lock_for(&timeout_duration == &Sync::SyncTimeoutDeedlock ? m_timeout : timeout_duration);
                } else {
                    return std::get<std::shared_timed_mutex>(m_sync).try_lock_shared_for(&timeout_duration == &Sync::SyncTimeoutDeedlock ? m_timeout : timeout_duration);
                }
            } else if (m_type == RefType::SyncMulti || m_type == RefType::SyncMultiConst) {
                ASSERT(std::holds_alternative<std::recursive_timed_mutex>(m_sync));
                return std::get<std::recursive_timed_mutex>(m_sync).try_lock_for(&timeout_duration == &Sync::SyncTimeoutDeedlock ? m_timeout : timeout_duration);
            }
            return true;
        }
 
        inline bool SyncUnLock() {
            ASSERT(m_type != RefType::Value);
            if (m_type == RefType::LiteSingle || m_type == RefType::LiteSingleConst) {
                ASSERT(m_thread_id == std::this_thread::get_id());
            } else if (m_type == RefType::SyncMono || m_type == RefType::SyncMonoConst) {
                ASSERT(std::holds_alternative<std::shared_timed_mutex>(m_sync));
                std::get<std::shared_timed_mutex> (m_sync).unlock();
            } else if (m_type == RefType::SyncMulti || m_type == RefType::SyncMultiConst) {
                ASSERT(std::holds_alternative<std::recursive_timed_mutex>(m_sync));
                std::get<std::recursive_timed_mutex>(m_sync).unlock();
            }
            return true;
        }
 
        virtual ~Sync() {
        }
    };
 
    class VariableTaken : public std::runtime_error {
        friend class Variable;
 
        SCOPE(protected) :
        std::variant<Variable *, std::shared_ptr<Variable>, std::shared_ptr<Sync>> variable;
 
 
        explicit VariableTaken(const Variable & var, bool edit_mode,
                const std::chrono::milliseconds & timeout_duration = Sync::SyncTimeoutDeedlock,
                const std::string_view message = "",
                const std::source_location & location = std::source_location::current());
 
        static std::string MakeTimeoutMessage(const Variable & var, bool edit_mode,
                const std::chrono::milliseconds & timeout_duration,
                const std::string_view message, const std::source_location & location);
 
    public:
 
        inline operator bool() const {
            if(std::holds_alternative<Variable *> (variable)){
                return std::get<Variable *> (variable);
            } else if(std::holds_alternative<std::shared_ptr<Variable>> (variable)){
                return std::get<std::shared_ptr<Variable>>(variable).get();
            }
            return std::get<std::shared_ptr<Sync>>(variable).get() && std::get<std::shared_ptr<Sync>>(variable)->m_data;
        }
 
        inline const Variable & operator*() const {
            if(std::holds_alternative<Variable *> (variable)){
                ASSERT(std::get<Variable *> (variable));
                return *std::get<Variable *> (variable);
            } else if(std::holds_alternative<std::shared_ptr<Variable>> (variable)){
                ASSERT(std::get<std::shared_ptr<Variable>> (variable));
                return *std::get<std::shared_ptr<Variable>> (variable);
            }
            ASSERT(std::get<std::shared_ptr<Sync>>(variable));
            ASSERT(std::get<std::shared_ptr<Sync>>(variable)->m_data);
            return *(std::get<std::shared_ptr<Sync>>(variable))->m_data;
        }
 
        inline Variable & operator*() {
            if(std::holds_alternative<Variable *> (variable)){
                ASSERT(std::get<Variable *> (variable));
                return *std::get<Variable *> (variable);
            } else if(std::holds_alternative<std::shared_ptr<Variable>> (variable)){
                ASSERT(std::get<std::shared_ptr<Variable>> (variable));
                return *std::get<std::shared_ptr<Variable>> (variable);
            }
            ASSERT(std::get<std::shared_ptr<Sync>>(variable));
            ASSERT(std::get<std::shared_ptr<Sync>>(variable)->m_data);
            return *std::get<std::shared_ptr<Sync>>(variable)->m_data;
        }
        
        VariableTaken & operator=(VariableTaken const& var) noexcept {
            this->variable = var.variable;
            return *this;
        }
 
        ~VariableTaken();
    };
 
    template< typename R, typename... Args>
    class VirtualFuncImpl : public std::vector<void *> {
    public:
 
        typedef R VirtualFuncType(Args... args);
 
        explicit VirtualFuncImpl(VirtualFuncType *func) {
            push_back(reinterpret_cast<void *> (func));
        }
 
        VirtualFuncImpl(std::initializer_list<VirtualFuncType *> list) {
            for (auto func : list) {
                push_back(reinterpret_cast<void *> (func));
            }
        }
 
        inline R operator()(Args... args) {
            ASSERT(!empty());
            return (*reinterpret_cast<VirtualFuncType *> (back()))(args...);
        }
 
        VirtualFuncType * override(VirtualFuncType *func) {
            VirtualFuncType * result = reinterpret_cast<VirtualFuncType *> (back());
            push_back(reinterpret_cast<void *> (func));
            return result;
        }
 
        VirtualFuncType * parent(VirtualFuncType *current) {
            for (auto it = rbegin(); it != rend(); it++) {
                if (reinterpret_cast<void *> (current) == *it) {
                    ++it;
                    return reinterpret_cast<VirtualFuncType *> (*it);
                }
            }
            return nullptr;
        }
 
    };
 
    class VariableOp {
    public:
        typedef VirtualFuncImpl<Variable &, Variable &, const Variable &> OperatorType;
 
        static VirtualFuncImpl<Variable, const Variable &> copy;
        static Variable __copy__(const Variable &copy);
 
        static VirtualFuncImpl<Variable, const Variable &> clone;
        static Variable __clone__(const Variable &clone);
 
        static VirtualFuncImpl<int, const Variable &, const Variable &> eq;
        static int __eq__(const Variable &self, const Variable &other);
 
        static VirtualFuncImpl<bool, const Variable &, const Variable &> strict_eq;
        static bool __strict_eq__(const Variable &self, const Variable &other);
 
 
#define DEFINE_OPERATOR(name)  static OperatorType name; \
                               static Variable& __ ## name ## __(Variable &self, const Variable &other)
 
        /*
         *      x + y   __add__(self, other)        x += y      __iadd__(self, other)
         *      x - y   __sub__(self, other)        x -= y      __isub__(self, other)
         *      x * y   __mul__(self, other)        x *= y      __imul__(self, other)
         *      x / y   __truediv__(self, other)    x /= y      __itruediv__(self, other)
         *      x // y  __floordiv__(self, other)   x //= y     __ifloordiv__(self, other)
         *      x % y   __mod__(self, other)        x %= y      __imod__(self, other) 
         */
 
        DEFINE_OPERATOR(iadd);
        DEFINE_OPERATOR(isub);
        DEFINE_OPERATOR(imul);
        DEFINE_OPERATOR(itruediv);
        DEFINE_OPERATOR(ifloordiv);
        DEFINE_OPERATOR(imod);
 
#undef DEFINE_OPERATOR
        static Variable& __iadd_only_numbers__(Variable &self, const Variable &other);
        static Variable& __imul_only_numbers__(Variable &self, const Variable &other);
 
    };
 
 
    struct VariableShared {
        std::shared_ptr<Variable> data; // Сильный указатель на данные (владеющая ссылка)
        std::shared_ptr<Sync> sync; 
    };
    struct VariableWeak {
        std::weak_ptr<Variable> weak; 
        std::shared_ptr<Sync> sync;  
    };
 
    typedef std::variant< std::monostate, // Не инициализированная переменная
    VariableShared, // Ссылочная или не захваченная защищенная переменная (владеющая ссылка)
    VariableWeak, // Ссылочная переменная (слабая ссылка)
    VariableTaken, // Захваченная защищенная или ссылочная переменная
    // Далее идут варинаты данных 
    ObjPtr, // Универсальный объект
    int64_t, double, std::string, std::wstring, Rational //, void * // Оптимизация для типизированных переменных
    > VariableVariant;
 
    
#define VARIABLE_TYPES(_)       \
            _(EMPTY,    0)      \
            _(SHARED,   1)      \
            _(WEAK,     2)      \
            _(TAKEN,    3)      \
            \
            _(OBJECT,   4)      \
            _(INTEGER,  5)      \
            _(DOUBLE,   6)      \
            _(STRING,   7)      \
            _(WSTRING,  8)      \
            _(RATIONAL, 9)      
    //            _(POINTER,  10)
 
    enum class VariableCase : uint8_t {
#define DEFINE_ENUM(name, value) name = static_cast<uint8_t>(value),
        VARIABLE_TYPES(DEFINE_ENUM)
#undef DEFINE_ENUM
    };
 
#define MAKE_TYPE_NAME(type_name)  type_name
 
    inline const char * VariableCaseToString(size_t index) {
#define DEFINE_CASE(name, _)                                    \
    case VariableCase:: name :                                  \
        return MAKE_TYPE_NAME(":" #name);
 
        switch (static_cast<VariableCase> (index)) {
                VARIABLE_TYPES(DEFINE_CASE)
 
            default:
                LOG_RUNTIME("UNKNOWN VariableVariant index %d", static_cast<int> (index));
        }
#undef DEFINE_CASE
#undef MAKE_TYPE_NAME
    }
 
    static_assert(static_cast<size_t> (VariableCase::EMPTY) == 0);
    static_assert(static_cast<size_t> (VariableCase::SHARED) == 1);
    static_assert(static_cast<size_t> (VariableCase::WEAK) == 2);
    static_assert(static_cast<size_t> (VariableCase::TAKEN) == 3);
    static_assert(std::is_same_v<std::monostate, std::variant_alternative_t < static_cast<size_t> (VariableCase::EMPTY), VariableVariant>>);
    static_assert(std::is_same_v<VariableShared, std::variant_alternative_t < static_cast<size_t> (VariableCase::SHARED), VariableVariant>>);
    static_assert(std::is_same_v<VariableWeak, std::variant_alternative_t < static_cast<size_t> (VariableCase::WEAK), VariableVariant>>);
    static_assert(std::is_same_v<VariableTaken, std::variant_alternative_t < static_cast<size_t> (VariableCase::TAKEN), VariableVariant>>);
 
    static_assert(std::is_same_v<ObjPtr, std::variant_alternative_t < static_cast<size_t> (VariableCase::OBJECT), VariableVariant>>);
    static_assert(std::is_same_v<int64_t, std::variant_alternative_t < static_cast<size_t> (VariableCase::INTEGER), VariableVariant>>);
    static_assert(std::is_same_v<double, std::variant_alternative_t < static_cast<size_t> (VariableCase::DOUBLE), VariableVariant>>);
    static_assert(std::is_same_v<std::string, std::variant_alternative_t < static_cast<size_t> (VariableCase::STRING), VariableVariant>>);
    static_assert(std::is_same_v<std::wstring, std::variant_alternative_t < static_cast<size_t> (VariableCase::WSTRING), VariableVariant>>);
    static_assert(std::is_same_v<Rational, std::variant_alternative_t < static_cast<size_t> (VariableCase::RATIONAL), VariableVariant>>);
    //    static_assert(std::is_same_v<void *, std::variant_alternative_t < static_cast<size_t> (VariableCase::POINTER), VariableVariant>>);
 
    template<typename T> struct is_shared_ptr : std::false_type {
    };
    template<typename T> struct is_shared_ptr<std::shared_ptr<T>> : std::true_type
    {
    };
 
    class Variable : public VariableVariant {
        friend class GlobalObjects;
 
        SCOPE(protected) :
        //        mutable std::shared_ptr<Sync> sync; ///< Объект синхронизации доступа к защищённой переменной
 
        //        Variable(const Variable& var) : VariableVariant(static_cast<VariableVariant> (var)), sync(var.sync) {
        //            ASSERT(!sync); // Block copy guard variable
        //        }
 
        //        explicit Variable(VariableVariant val, std::shared_ptr<Sync> s) : VariableVariant(val), sync(s) {
        //        }
 
        //        Variable& operator=(const Variable& var) noexcept {
        //            static_cast<VariableVariant> (*this) = static_cast<VariableVariant> (var);
        //            sync = var.sync;
        //            ASSERT(!sync); // Block copy guard variable
        //            return *this;
        //        }
        //
        //        Variable& operator=(Variable& var) noexcept {
        //            static_cast<VariableVariant> (*this) = static_cast<VariableVariant> (var);
        //            sync = std::move(var.sync);
        //            ASSERT(!sync); // Block copy guard variable
        //            return *this;
        //        }
 
        static bool isShared(const TermPtr &term);
        //        static std::unique_ptr<Sync> MakeSync(const TermPtr &term);
        //        static std::unique_ptr<Sync> MakeSync(const std::string_view ref);
 
        inline Variable copy() {
            return VariableOp::copy(*this);
        }
 
        static VariablePtr UndefinedPtr() {
            return std::make_shared<Variable>(std::monostate());
        }
        //        explicit Variable(const VarWeak &ref) : sync(nullptr) {
        //        }
        //
        //        explicit Variable(const VarPtr &ptr) : sync(nullptr) {
        //        }
        //
        //        explicit Variable(std::unique_ptr<VarGuard> taken) : sync(nullptr) {
        //        }
 
    public:
 
        //        template <class T>
        //        typename std::enable_if<is_shared_ptr<decltype(std::declval<T>().value)>::value, void>::type
        //        func(T t) {
        //            std::cout << "shared ptr" << std::endl;
        //        }
        //
        //        template <class T>
        //        typename std::enable_if<!is_shared_ptr<decltype(std::declval<T>().value)>::value, void>::type
        //        func(T t) {
        //            std::cout << "non shared" << std::endl;
        //        }
 
        explicit Variable(ObjPtr obj) : VariableVariant(obj) {
        }
 
        template <class T, typename = typename std::enable_if<!is_shared_ptr<decltype(std::declval<T>())>::value>::type>
        Variable(T value) : VariableVariant(value) {
        }
 
        template <typename T, typename = typename std::enable_if<!is_shared_ptr<decltype(std::declval<T>())>::value>::type>
        Variable(T value, const TermPtr && term) :
        VariableVariant(isShared(term) ? static_cast<VariableVariant> (VariableShared(std::make_shared<Variable>(value), Sync::CreateSync(term))) : value) {
        }
 
        template <typename T, typename = typename std::enable_if<!is_shared_ptr<decltype(std::declval<T>())>::value>::type>
        Variable(T value, const std::string_view ref) :
        VariableVariant(ref.empty() ? value : static_cast<VariableVariant> (VariableShared(std::make_shared<Variable>(value), Sync::CreateSync(ref)))) {
        }
 
 
        //        Variable(const Variable &&value);
        //
        //        template <typename T, typename = typename std::enable_if<!is_shared_ptr<decltype(std::declval<T>())>::value>::type>
        //        Variable(T shared, std::unique_ptr<Sync> s) : VariableVariant(std::make_shared<T>(value)), sync(std::move(s)) {
        //        }
 
 
        //        template <typename D, typename T> static VarPtr Create(D d, T ref = nullptr) {
        //            return std::make_shared<VarData>(d, ref);
        //        }
        //
 
        //        template <typename D> static VariableType CreatePair(TermPtr term, D d) {
        //            return std::make_shared<VariablePair>(term, Variable(d));
        //        }
 
        static ObjPtr Object(Variable * variable);
        static ObjPtr Object(VariablePair * pair);
        //
        //        static Variable Undefined() {
        //            return Variable(std::monostate());
        //        }
        //
        //        static VarPtr UndefinedPtr() {
        //            return std::make_shared<Variable>(std::monostate());
        //        }
        //        //        static VarWeak GetWeak(const VarData & data){
        //        //            return std::weak_ptr<VarData>(data.owner);
        //        //        }
 
        inline bool is_undefined() const {
            return std::holds_alternative<std::monostate>(*this);
        }
 
        inline bool is_taked() const {
            STATIC_ASSERT(static_cast<size_t> (VariableCase::TAKEN) == 3);
            return this->index() >= static_cast<size_t> (VariableCase::TAKEN) ||
                    (std::holds_alternative<VariableShared> (*this) && !std::get<VariableShared>(*this).sync);
        }
 
        inline bool is_shared() const {
            return std::holds_alternative<VariableShared> (*this) ||
                    std::holds_alternative<VariableTaken> (*this) ||
                    std::holds_alternative<VariableWeak> (*this);
        }
 
 
        Variable Ref(const std::string_view ref) const;
 
        inline Variable Take(bool edit_mode = false, const std::chrono::milliseconds & timeout_duration = Sync::SyncTimeoutDeedlock,
                const std::string_view message = "", const std::source_location location = std::source_location::current()) const {
            return VariableTaken(*this, edit_mode, timeout_duration, message, location);
        }
 
        inline const Variable & operator*() const {
            if (is_taked()) {
                return *this;
            }
            return *Take();
        }
 
 
        bool GetValueAsBoolean() const;
        int64_t GetValueAsInteger() const;
        double GetValueAsNumber() const;
        std::string & GetValueAsString();
        std::wstring & GetValueAsStringWide();
 
        Rational GetValueAsRational() const;
 
        ObjPtr GetValueAsObject() const;
        void * GetValueAsPointer() const;
        std::string toString() const;
 
        /*
         *  Cast operators
         * 
         */
        explicit inline operator bool() const {
            return GetValueAsBoolean();
        }
 
#define PLACE_RANGE_CHECK_VALUE(itype, utype)\
        explicit inline operator itype() const { \
            int64_t result = GetValueAsInteger(); \
            if (result > std::numeric_limits<itype>::max() || result < std::numeric_limits<itype>::lowest()) { \
                LOG_RUNTIME("Value '%s' is out of range of the casting type %s!", toString().c_str(), #itype); \
            } \
            return result; \
        } \
        explicit inline operator utype() const { \
            int64_t result = GetValueAsInteger(); \
            if (result > std::numeric_limits<utype>::max() || result < 0) { \
                LOG_RUNTIME("Value '%s' is out of range of the casting type %s!", toString().c_str(), #utype); \
            } \
            return result; \
        }
 
        PLACE_RANGE_CHECK_VALUE(int8_t, uint8_t);
        PLACE_RANGE_CHECK_VALUE(int16_t, uint16_t);
        PLACE_RANGE_CHECK_VALUE(int32_t, uint32_t);
 
        explicit inline operator int64_t() const {
            return GetValueAsInteger();
        }
 
        explicit inline operator uint64_t() const {
            int64_t result = GetValueAsInteger();
            if (result < 0) {
                LOG_RUNTIME("Value '%s' is out of range of the casting type %s!", toString().c_str(), "uint64_t");
            }
            return result;
        }
 
 
#undef PLACE_RANGE_CHECK_VALUE
 
        //        explicit inline operator float() const {
        //            double result = GetValueAsNumber();
        //            if (result > (double) std::numeric_limits<float>::max()) {
        //                LOG_RUNTIME("Value1 '%s' %.20f %.20f %.20f is out of range of the casting type float!", toString().c_str(), result, std::numeric_limits<float>::max(), std::numeric_limits<float>::lowest());
        //            }
        //
        //            //    __asm__ volatile ( "; //SOURCE: __FLT_MAX__ ");
        //            if (result < -__FLT_MAX__) {//(double) std::numeric_limits<float>::lowest()) {
        //                LOG_RUNTIME("Value2 '%s' %.20f %.20f %.20f is out of range of the casting type float!", toString().c_str(), result, std::numeric_limits<float>::max(), std::numeric_limits<float>::lowest());
        //            }
        //            LOG_DEBUG("operator float() '%s' %.20f", toString().c_str(), result);
        //            return result;
        //        }
 
        //        explicit inline operator double() const {
        //            return GetValueAsNumber();
        //        }
 
        explicit inline operator std::string() const {
            return toString();
        }
 
        explicit inline operator std::wstring() const {
            return newlang::utf8_decode(toString());
        }
 
        explicit operator void *() const {
            return GetValueAsPointer();
        }
 
        explicit inline operator Rational() const {
            return GetValueAsRational();
        }
 
 
        //        void set(const ObjPtr & value, bool edit_mode = false, const std::chrono::milliseconds & timeout_duration = Sync::SyncTimeoutDeedlock);
        //
        //        template <typename T>
        //        typename std::enable_if<!std::is_same<T, ObjPtr>::value, void>::type
        //        set(const T & new_value, bool edit_mode = false, const std::chrono::milliseconds & timeout_duration = Sync::SyncTimeoutDeedlock);
 
        inline Variable & operator+=(const Variable &other) {
            return VariableOp::iadd(*this, other);
        }
 
        inline const Variable operator+(const Variable &other) {
            Variable result(VariableOp::copy(other));
            result += other;
            return result;
        }
 
        inline Variable & operator-=(const Variable &other) {
            return VariableOp::isub(*this, other);
        }
 
        inline const Variable operator-(const Variable &other) {
            Variable result(VariableOp::copy(other));
            result += other;
            return result;
        }
 
        inline Variable & operator*=(const Variable &other) {
            return VariableOp::imul(*this, other);
        }
 
        inline const Variable operator*(const Variable &other) {
            Variable result(VariableOp::copy(other));
            result += other;
            return result;
        }
 
        inline Variable & operator/=(const Variable &other) {
            return VariableOp::itruediv(*this, other);
        }
 
        inline const Variable operator/(const Variable &other) {
            Variable result(VariableOp::copy(other));
            result += other;
            return result;
        }
 
        inline Variable & operator%=(const Variable &other) {
            return VariableOp::imod(*this, other);
        }
 
        inline const Variable operator%(const Variable &other) {
            Variable result(VariableOp::copy(other));
            result += other;
            return result;
        }
 
        /*
         * 
         * 
         */
 
        bool is_object_type() const;
        bool is_scalar_type() const;
        bool is_floating_type() const;
        bool is_complex_type() const;
        bool is_rational_type() const;
        bool is_string_type() const;
 
        /*
         * 
         */
        inline bool operator==(const Variable & other) const {
            return VariableOp::eq(*this, other) == 0;
        }
 
        inline bool operator<=(const Variable & other) const {
 
            return VariableOp::eq(*this, other) <= 0;
        }
 
        inline bool operator<(const Variable &other) const {
 
            return VariableOp::eq(*this, other) < 0;
        }
 
        inline bool operator>=(const Variable &other) const {
 
            return VariableOp::eq(*this, other) >= 0;
        }
 
        inline bool operator>(const Variable &other) const {
 
            return VariableOp::eq(*this, other) > 0;
        }
 
        inline bool operator!=(const Variable &other) const {
 
            return VariableOp::eq(*this, other) != 0;
        }
 
        inline int compare(const Variable &other) const {
 
            return VariableOp::eq(*this, other);
        }
 
        inline bool strict_eq(const Variable &other) const {
            return VariableOp::strict_eq(*this, other);
        }
    };
 
} // namespace newlang
 
 
#endif // INCLUDED_VARIABLE_H_