AMProperty.h

Go to the documentation of this file.

#ifndef AMPROPERTY_H
#define AMPROPERTY_H

#include <exception>

#include <string>
#include <sstream>

#ifdef DEBUG
#include <stdio.h>
#include <cstring>
#define AMProperty_log(...) printf(__VA_ARGS__)
#else
#define AMProperty_log(...)
#endif


#include <AMSmartProperties/AMFunction.h>

namespace std{
    template<typename T> string to_string(const T&);
    template<typename T> string to_string(T&);
};


namespace AMSmartProperties {


class AMPropertyBase;
class AMPropertyRefBase;
class AMPropertyPool;

struct AMPropertyGeneralException : std::exception {

     AMPropertyPool &m_pool;
public:
    AMPropertyGeneralException(AMPropertyPool &pool);
    const char* what() const noexcept {return "AMProperty: Use descendant of this exception to identify a problem.";}
     //const char* what() const noexcept {return "";}
     AMPropertyBase* propertyEntered() const noexcept;
     AMPropertyBase* propertyCaused() const noexcept;
      std::string trace();
};

struct AMPropertyDeletedException : AMPropertyGeneralException {


    AMPropertyDeletedException(AMPropertyPool &pool): AMPropertyGeneralException(pool) {}
    const char* what() const noexcept {return "AMProperty: Detected deleted property. Member propertyXXX() show which property causes an exception. Run trace() to explain.";}
};


struct AMPropertyLoopException : AMPropertyGeneralException {


    AMPropertyLoopException(AMPropertyPool &pool): AMPropertyGeneralException(pool) {}
    const char* what() const noexcept {return "AMProperty: Detected loop. Member propertyXXX() show which property causes an exception. Run trace() to explain.";}
};

struct AMPropertyNestingException : AMPropertyGeneralException {


    AMPropertyNestingException(AMPropertyPool &pool): AMPropertyGeneralException(pool) {}
    const char* what() const noexcept {return "AMProperty: Detected too depth nesting. Member propertyXXX() show which property causes an exception. Run trace() to explain.";}
};


enum  AMPropertyState
{
    NORMAL = 0, 
    COMPUTING = 1, 
    NOCOMPUTED = 2, 
    NOCOMPUTED_COMPUTING = 3, 
    VALUEONLY = 4, 
    VALUEONLY_COMPUTING = 5, 
    VALUEONLY_NOCOMPUTED = 6, 
    VALUEONLY_NOCOMPUTED_COMPUTING = 7, 
    MODIFIED = 8, 
    MODIFIED_COMPUTING = 9, 
    MODIFIED_NOCOMPUTED = 10, 
    MODIFIED_NOCOMPUTED_COMPUTING = 11, 
    MODIFIED_VALUEONLY = 12, 
    MODIFIED_VALUEONLY_COMPUTING = 13, 
    MODIFIED_VALUEONLY_NOCOMPUTED = 14, 
    MODIFIED_VALUEONLY_NOCOMPUTED_COMPUTING = 15, 
    DESTROYED_NORMAL = 16, 
    DESTROYED_COMPUTING = 17, 
    DESTROYED_NOCOMPUTED = 18, 
    DESTROYED_NOCOMPUTED_COMPUTING = 19, 
    DESTROYED_VALUEONLY = 20, 
    DESTROYED_VALUEONLY_COMPUTING = 21, 
    DESTROYED_VALUEONLY_NOCOMPUTED = 22, 
    DESTROYED_VALUEONLY_NOCOMPUTED_COMPUTING = 23, 
    DESTROYED_MODIFIED = 24, 
    DESTROYED_MODIFIED_COMPUTING = 25, 
    DESTROYED_MODIFIED_NOCOMPUTED = 26, 
    DESTROYED_MODIFIED_NOCOMPUTED_COMPUTING = 27, 
    DESTROYED_MODIFIED_VALUEONLY = 28, 
    DESTROYED_MODIFIED_VALUEONLY_COMPUTING = 29, 
    DESTROYED_MODIFIED_VALUEONLY_NOCOMPUTED = 30, 
    DESTROYED_MODIFIED_VALUEONLY_NOCOMPUTED_COMPUTING = 31, 
};

std::string to_string(const AMPropertyState& state);


class AMPropertyPool {
public:
    static const int TRACE_SIZE = 1024;

protected:
    AMPropertyState m_state;
    AMPropertyBase* m_firstChild;

     AMPropertyBase* m_trace_array[TRACE_SIZE];
    AMPropertyBase** m_trace_iterator;
    AMPropertyBase** m_trace_stop;

public:
    AMPropertyPool();
    AMPropertyPool(AMPropertyState state);
    AMPropertyState getPoolState() {return m_state;}
    void setModified() {m_state = (AMPropertyState)((unsigned int)m_state | 0x8);}
    void reset();
     bool isDestroyed() {
         return ((static_cast<unsigned int>(m_state) & ~0xF ) == (static_cast<unsigned int>(AMPropertyState::DESTROYED_NORMAL)));
         }
     bool isInProgress() {
         return (m_trace_iterator != m_trace_array);
         }
    void runLoop();
    void runDeleted();
    std::string trace();
    void destroy();
    static AMPropertyPool& defaultPool();
    void dump(char* buffer = nullptr, int length = 0);
     AMPropertyBase* getEnteringProperty();
     AMPropertyBase* getLastCausedProperty();

     friend class AMPropertyBase;
     friend class AMPropertyRefBase;
protected:
     void plusDepthTraceItem(AMPropertyBase* item) {
        (*m_trace_iterator) = item;
        m_trace_iterator++;
        if (m_trace_iterator == m_trace_array+TRACE_SIZE) {throw AMPropertyNestingException(*this);}
        }
    void minusDepth() {if (m_trace_iterator == m_trace_array) {throw std::underflow_error("AMPropertyPool: Out of range");};m_trace_iterator--;}
     void addToPool(AMPropertyBase* property);
     void removeFromPool(AMPropertyBase* property);
};



class AMPropertyBase
{
     friend class AMPropertyPool;
protected:

    AMPropertyPool* m_pool;
    union {
        AMPropertyBase* m_next;
        AMPropertyState m_state;
        unsigned long   m_uint;
    };

    AMPropertyBase(AMPropertyPool& pool): m_pool(&pool), m_uint((unsigned long)NOCOMPUTED)  { m_pool->addToPool(this); }
    ~AMPropertyBase() {m_pool->removeFromPool(this);}
public:
    AMPropertyPool& getPool() const {return *m_pool;}
    void setPool(AMPropertyPool& newPool) { m_pool->removeFromPool(this);m_pool = (&newPool);m_pool->addToPool(this); }
    AMPropertyBase* getNext() const {return reinterpret_cast<AMPropertyBase*>(m_uint & ~0x3);}
    void resetState() {m_uint &= ~0x3;m_uint |= 0x2;}
     bool isNonComputed() const {return m_uint & 0x2;}
     void setNoComputedFlag() {m_uint |= 0x2;}
     void setNoComputed(bool noComputed) {m_uint = noComputed ? m_uint | 0x2 : m_uint & ~0x2;}
     bool getComputingFlag() {return m_uint & 0x1;}
     bool isInProgress() {return getPool().isInProgress();}
    void runLoop();

     void runDeleted();

     AMPropertyState getState(AMPropertyState valueOnly) const {return  static_cast<AMPropertyState>(static_cast<unsigned int>(getPool().getPoolState()) | (m_uint & 0x3) | static_cast<unsigned int>(valueOnly));}
     std::string to_string() const;

protected:
    void setComputingFlag() {m_uint |= 0x1;}
    void clearComputingFlag() {m_uint &= ~0x1;}
    void clearComputingAndNocomputedFlag() {m_uint &= ~0x3;}
    void setModified() {setNoComputedFlag();getPool().setModified();}
     void plusDepthTraceItem(AMPropertyBase* item) {getPool().plusDepthTraceItem(item);}
    void minusDepth() {getPool().minusDepth();}
     void setNext(AMPropertyBase* newNext) { m_uint = reinterpret_cast<unsigned long>(newNext) | (m_uint & 0x3); }
     void setVariableName(const void* ptr, const char * prefix, const char * delimiter, const char * name) const;
     bool isEnabledVariableNames() const;
     std::string getVariableName(const void* ptr) const;
     const char* getVariableNameCStr(const void* ptr) const;
};

template<typename T, typename TSubProperties, typename TParent, T TParent::*pointer_member>
class AMPropertyKernel
{
    T*const m_memberPtr;
public:
    constexpr AMPropertyKernel(AMPropertyPool& pool, T*const valuePtr): m_memberPtr(valuePtr){};
    TParent* getParentPointer() {
        union {
            T TParent::*my_pointer_member = pointer_member;
            int offset;
        };
        return (TParent*)(((void*)m_memberPtr) - offset);
        }
    TParent& getParent() {return *getParentPointer();}

    T& getT() {return *(m_memberPtr);};
    const T& getTconst() const {return *m_memberPtr;};
    T*const getTPointerConst() const {return m_memberPtr;}
     T* getTPointer() {return m_memberPtr;}

    constexpr TSubProperties* getSubpropertiesPtr() {return nullptr;}
    constexpr T TParent::* getPointerToMember() {return pointer_member;}

    void compute() {};
    void setDescription(const char * desc) {}
     void setPool(AMPropertyPool& pool) {}

    void to_string_valptr(std::ostringstream& os) const {os<<"val="<<((reinterpret_cast<const unsigned long>(m_memberPtr) <= sizeof(TSubProperties)) ? std::string("nullptr") : std::to_string(*m_memberPtr))<<", ptr="<<std::hex<<m_memberPtr;}
    void to_string_subprops(std::ostringstream& os) const {};
};

template<typename T, typename TSubProperties, typename TParent, T TParent::*pointer_member>
class AMPropertyKernelWithSub
{
    T*const         m_memberPtr;
    TSubProperties  m_subMembers;
public:
    constexpr AMPropertyKernelWithSub(AMPropertyPool& pool, T*const valuePtr): m_memberPtr(valuePtr), m_subMembers(pool, m_memberPtr){};
    TParent* getParentPointer() {
        union {
            T TParent::*my_pointer_member = pointer_member;
            int offset;
        };
        return (TParent*)(((void*)m_memberPtr) - offset);
        }
    TParent& getParent() {return *getParentPointer();}

    T& getT() {return *(m_memberPtr);};
    const T& getTconst() const {return *m_memberPtr;};
     T*const getTPointerConst() const {return m_memberPtr;}
     T* getTPointer() {return m_memberPtr;}


    constexpr TSubProperties* getSubpropertiesPtr() {return &m_subMembers;}
    constexpr T TParent::* getPointerToMember() {return pointer_member;}

    void compute() {m_subMembers.compute();}
    void setDescription(const char * desc) {m_subMembers.setDescription(desc);}
     void setPool(AMPropertyPool& pool) {m_subMembers.setPool(pool);}

    void to_string_valptr(std::ostringstream& os) const {os<<"val="<<((reinterpret_cast<const unsigned long>(m_memberPtr) <= sizeof(TSubProperties)) ? std::string("nullptr") : std::to_string(*m_memberPtr))<<", ptr="<<std::hex<<m_memberPtr;}
    void to_string_subprops(std::ostringstream& os) const {os<<m_subMembers.to_string();};
};

template<typename T, typename TSubProperties, typename TParent, T TParent::*pointer_member>
class AMPropertyKernelWithT
{
    T               m_value;
public:
    constexpr AMPropertyKernelWithT(AMPropertyPool& pool, T*const valuePtr): m_value(valuePtr == nullptr? T() : *valuePtr){};
    TParent* getParentPointer(){return nullptr;}

    T& getT() {return m_value;};
    const T& getTconst() const {return m_value;};
     T*const getTPointerConst() const {T& ref=const_cast<T&>(m_value);return &ref;}
     T* getTPointer() {return &m_value;}


    constexpr TSubProperties* getSubpropertiesPtr() {return nullptr;}
    constexpr T TParent::* getPointerToMember() {return pointer_member;}

    void compute() {}
    void setDescription(const char * desc) {}
     void setPool(AMPropertyPool& pool) {}

    void to_string_valptr(std::ostringstream& os) const {os<<"val="<<std::to_string(m_value);}
    void to_string_subprops(std::ostringstream& os) const {};
};

template<typename T, typename TSubProperties, typename TParent, T TParent::*pointer_member>
class AMPropertyKernelWithTWithSub
{
    T               m_value;
    TSubProperties  m_subMembers;
public:
    constexpr AMPropertyKernelWithTWithSub(AMPropertyPool& pool, T*const valuePtr): m_value(valuePtr == nullptr? T() : *valuePtr), m_subMembers(pool, &m_value){};
    TParent* getParentPointer(){return nullptr;}

    T& getT() {return m_value;};
    const T& getTconst() const {return m_value;};
     T*const getTPointerConst() const {T& ref=const_cast<T&>(m_value);return &ref;}
     T* getTPointer() {return &m_value;}

    constexpr TSubProperties* getSubpropertiesPtr() {return &m_subMembers;}
    constexpr T TParent::* getPointerToMember() {return pointer_member;}

    void compute() {m_subMembers.compute();}
    void setDescription(const char * desc) {m_subMembers.setDescription(desc);}
     void setPool(AMPropertyPool& pool) {m_subMembers.setPool(pool);}

    void to_string_valptr(std::ostringstream& os) const {os<<"val="<<std::to_string(m_value);}
    void to_string_subprops(std::ostringstream& os) const {os<<m_subMembers.to_string();};
};


class AMPropertyNonBase
{
};


template<typename T, typename TSubProperties, typename TParent, T TParent::*pointer_member>
class AMProperty;


class AMPropertyRefBase
{
     friend class AMPropertyPool;

protected:
     AMPropertyBase*    m_target;
     AMPropertyRefBase(AMPropertyBase* target) : m_target(target) {}
     ~AMPropertyRefBase() {}
     AMPropertyBase* getTarget() {return m_target;}
     void setTarget(AMPropertyBase* target) {m_target = target;}
};


template<typename T, typename TSubProperties = T, typename TParent = AMPropertyNonBase, T TParent::*pointer_member = nullptr>
class AMProperty: public AMPropertyBase
{

public:
    typedef AMFunction<T()> type_fn;
protected:
    type_fn m_f;

    typename std::conditional< pointer_member != nullptr,
        typename std::conditional< std::is_same<T,TSubProperties>::value, AMPropertyKernel<T, TSubProperties, TParent, pointer_member>, AMPropertyKernelWithSub<T, TSubProperties, TParent, pointer_member> >::type  ,
        typename std::conditional< std::is_same<T,TSubProperties>::value, AMPropertyKernelWithT<T, TSubProperties, TParent, pointer_member>, AMPropertyKernelWithTWithSub<T, TSubProperties, TParent, pointer_member> >::type
    >::type m_kernel;


public:
    AMProperty(AMPropertyPool& pool, T*const ptr): AMPropertyBase(pool), m_f(nullptr), m_kernel(pool, ptr)
    {
        static_assert(pointer_member != nullptr, "This constructor is intended only for subproperties, do not use it.");
        AMProperty_log("AMProperty(%p)::AMProperty(T* ptr=%p) %s\n",this, ptr,to_string().c_str());
    }
    AMProperty(AMPropertyPool& pool, const char* name = nullptr): AMPropertyBase(pool), m_f(nullptr), m_kernel(pool, nullptr)
    {
        static_assert(pointer_member == nullptr, "This constructor is not intended for subproperties, do not use it.");
          AMProperty_log("AMProperty(%p)::AMProperty() %s\n",this,to_string().c_str());
        setVariableName(this, "", "", name);
        m_kernel.setDescription(name);

    };
    AMProperty(AMPropertyPool& pool, T value, const char* name = nullptr): AMPropertyBase(pool), m_f(nullptr), m_kernel(pool, &value)
    {
        static_assert(pointer_member == nullptr, "This constructor is not intended for subproperties, do not use it.");
          AMProperty_log("AMProperty(%p)::AMProperty(T value=%s) %s\n",this, std::to_string(value).c_str(),to_string().c_str());
        setVariableName(this, "", "", name);
        m_kernel.setDescription(name);

    };
    constexpr AMProperty(AMPropertyPool& pool, type_fn f, const char* name = nullptr): AMPropertyBase(pool), m_f(f), m_kernel(pool, nullptr)
    {
        static_assert(pointer_member == nullptr, "This constructor is not intended for subproperties, do not use it.");
          AMProperty_log("AMProperty(%p)::AMProperty(type_fn _f=%p) %s\n",&f,this,to_string().c_str());
        setVariableName(this, "", "", name);
        m_kernel.setDescription(name);

    };
    AMProperty(const AMProperty& other) : AMPropertyBase(other.getPool()), m_f(other.m_f), m_kernel(other.getPool(), other.m_kernel.getTPointerConst()){
          static_assert(pointer_member == nullptr, "This constructor is not intended for subproperties, do not use it.");
          AMProperty_log("AMProperty(%p)::AMProperty(AMProperty& other)) %s\n",this,other.to_string().c_str());
          const char* name = getVariableNameCStr(&other);
          setVariableName(this, "", "", name);
        m_kernel.setDescription(name);
    }
    constexpr AMProperty(AMProperty&& other) : AMPropertyBase(other.getPool()), m_f(std::move(other.m_f)), m_kernel(other.getPool(), other.m_kernel.getTPointer()){
          static_assert(pointer_member == nullptr, "This constructor is not intended for subproperties, do not use it.");
          AMProperty_log("AMProperty(%p)::AMProperty(AMProperty& other)) %s\n",this,other.to_string().c_str());
          const char* name = getVariableNameCStr(&other);
          setVariableName(this, "", "", name);
        m_kernel.setDescription(name);
          other.setPool(AMPropertyPool::defaultPool());
    }
    ~AMProperty()
    {
        AMProperty_log("AMProperty(%p)::AMProperty(%x)",this);
          setPool(AMPropertyPool::defaultPool());
    };
    void setValueFn(const type_fn& _f)
    {
        AMProperty_log("AMProperty(%p)::setValueFn(%p) %s\n",this, &_f,to_string().c_str());
        setModified();
        m_f=_f;
    };
    void setValueFn(const type_fn&& _f)
    {
        AMProperty_log("AMProperty(%p)::setValueFn(%p) %s\n",this, &_f,to_string().c_str());
        setModified();
        m_f=std::move(_f);
    };
    type_fn& getValueFn()
    {
        AMProperty_log("AMProperty(%p)::getValueFn() -> %p ---%s\n",this, &m_f,to_string().c_str());
        return m_f;
    };
     void setPool(AMPropertyPool& pool)
     {
          AMPropertyBase::setPool(pool);
          m_kernel.setPool(pool);
     }
    const T& getResult() const
     {
          return m_kernel.getTconst();
     }
    void setResult(T value)
     {
          AMProperty_log("AMProperty(%p)::setResult(%s) \n",this, std::to_string(m_kernel.getTconst()).c_str());
          m_kernel.getT() = value;
     }
    constexpr TSubProperties* getSubProperties()
     {
          /*AMProperty_log("AMProperty(%p)::T* operator->() %s\n",this,to_string().c_str());*/
          return m_kernel.getSubpropertiesPtr();
     }
    bool isValueOnly() const
     {
          return m_f == nullptr;
     }
    constexpr bool hasSubproperties() const
     {
          return pointer_member != nullptr;
     }
    T operator()()
    {
        AMProperty_log("AMProperty(%p)::const T& operator() const ->%s --- %s\n",(const void *)this, std::to_string(m_kernel.getTconst()).c_str(), to_string().c_str());
          compute();
          return getResult();
    }
    void compute()
    {
          AMProperty_log("AMProperty(%p)::compute --- %s\n",(const void *)this, to_string().c_str());
        AMPropertyState state = getState(m_f == nullptr ? AMPropertyState::VALUEONLY : AMPropertyState::NORMAL);
        switch(state) {
        case AMPropertyState::NORMAL:
                                    break;
        case AMPropertyState::COMPUTING:
                                    runLoop();
                                    break;
        case AMPropertyState::NOCOMPUTED:
                                    setComputingFlag();
                                    plusDepthTraceItem(this);
                                             setResult(m_f());
                                    minusDepth();
                                    clearComputingAndNocomputedFlag();
                                    break;
        case AMPropertyState::NOCOMPUTED_COMPUTING:
                                    runLoop();
                                    break;
        case AMPropertyState::VALUEONLY:
                                    break;
        case AMPropertyState::VALUEONLY_COMPUTING:
                                    runLoop();
                                    break;
        case AMPropertyState::VALUEONLY_NOCOMPUTED:
                                    plusDepthTraceItem(this);
                                    m_kernel.compute();
                                    minusDepth();
                                    break;
        case AMPropertyState::VALUEONLY_NOCOMPUTED_COMPUTING:
                                    runLoop();
                                    break;
        case AMPropertyState::MODIFIED:
                                             setComputingFlag();
                                             plusDepthTraceItem(this);
                                             setResult(m_f());
                                             minusDepth();
                                             clearComputingAndNocomputedFlag();
                                             break;
        case AMPropertyState::MODIFIED_COMPUTING:
                                    runLoop();
                                    break;
        case AMPropertyState::MODIFIED_NOCOMPUTED:
                                             setComputingFlag();
                                             plusDepthTraceItem(this);
                                             setResult(m_f());
                                             minusDepth();
                                             clearComputingAndNocomputedFlag();
                                             break;
        case AMPropertyState::MODIFIED_NOCOMPUTED_COMPUTING:
                                    runLoop();
                                    break;
        case AMPropertyState::MODIFIED_VALUEONLY:
                                    plusDepthTraceItem(this);
                                    m_kernel.compute();
                                    minusDepth();
                                    break;
        case AMPropertyState::MODIFIED_VALUEONLY_COMPUTING:
                                    runLoop();
                                    break;
        case AMPropertyState::MODIFIED_VALUEONLY_NOCOMPUTED:
                                    plusDepthTraceItem(this);
                                    m_kernel.compute();
                                             minusDepth();
                                    break;
        case AMPropertyState::MODIFIED_VALUEONLY_NOCOMPUTED_COMPUTING:
                                    runLoop();
                                    break;
        case AMPropertyState::DESTROYED_NORMAL:
        case AMPropertyState::DESTROYED_COMPUTING:
        case AMPropertyState::DESTROYED_NOCOMPUTED:
        case AMPropertyState::DESTROYED_NOCOMPUTED_COMPUTING:
        case AMPropertyState::DESTROYED_VALUEONLY:
        case AMPropertyState::DESTROYED_VALUEONLY_COMPUTING:
        case AMPropertyState::DESTROYED_VALUEONLY_NOCOMPUTED:
        case AMPropertyState::DESTROYED_VALUEONLY_NOCOMPUTED_COMPUTING:
        case AMPropertyState::DESTROYED_MODIFIED:
        case AMPropertyState::DESTROYED_MODIFIED_COMPUTING:
        case AMPropertyState::DESTROYED_MODIFIED_NOCOMPUTED:
        case AMPropertyState::DESTROYED_MODIFIED_NOCOMPUTED_COMPUTING:
        case AMPropertyState::DESTROYED_MODIFIED_VALUEONLY:
        case AMPropertyState::DESTROYED_MODIFIED_VALUEONLY_COMPUTING:
        case AMPropertyState::DESTROYED_MODIFIED_VALUEONLY_NOCOMPUTED:
        case AMPropertyState::DESTROYED_MODIFIED_VALUEONLY_NOCOMPUTED_COMPUTING:
                                             runDeleted();
                                    break;
          default: break;
        }
    }
    operator const T& ()
    {
        AMProperty_log("AMProperty(%p)::operator const T& () const ->%s --- %s\n",(const void *)this, std::to_string(m_kernel.getTconst()).c_str(), to_string().c_str());
          compute();
          return getResult();
    }
    const type_fn& operator = (const type_fn& right) {
        setValueFn(right);
        return getValueFn();
    }
    const type_fn& operator = (const type_fn&& right) {
        setValueFn(std::move(right));
        return getValueFn();
    }
    const T& operator = (const T& right) {
        setValueFn(nullptr);
        setResult(right);
        setModified();
        return right;
    }
    constexpr TSubProperties* operator->()
     {
          AMProperty_log("AMProperty(%p)::T* operator->() %s\n",this,to_string().c_str());
          return m_kernel.getSubpropertiesPtr();
     }
    T operator+(const T& other) {
        AMProperty_log("AMProperty(%p)::operator+(T&) %s --- %s\n",(const void *)this, to_string().c_str(), std::to_string(other));
          compute();
          T result =  getResult();
        result = result + other;
        return result;
    }
    T operator-(const T& other) {
        AMProperty_log("AMProperty(%p)::operator-(T&) %s --- %s\n",(const void *)this, to_string().c_str(), std::to_string(other));
          compute();
          T result =  getResult();
        result = result - other;
        return result;
    }
    T operator*(const T& other) {
        AMProperty_log("AMProperty(%p)::operator*(T&) %s --- %s\n",(const void *)this, to_string().c_str(), std::to_string(other));
          compute();
          T result =  getResult();
        result = result * other;
        return result;
    }
    T operator/(const T& other) {
        AMProperty_log("AMProperty(%p)::operator/(T&) %s --- %s\n",(const void *)this, to_string().c_str(), std::to_string(other));
          compute();
          T result =  getResult();
        result = result / other;
        return result;
    }
    T operator%(const T& other) {
        AMProperty_log("AMProperty(%p)::operator%(T&) %s --- %s\n",(const void *)this, to_string().c_str(), std::to_string(other));
          compute();
          T result =  getResult();
        result = result % other;
        return result;
    }
    T operator++() {
        AMProperty_log("AMProperty(%p)::operator++() %s\n",(const void *)this, to_string().c_str());
          compute();
          T result =  getResult();
        result = result++;
        return result;
    }
    T operator--() {
        AMProperty_log("AMProperty(%p)::operator--() %s\n",(const void *)this, to_string().c_str());
          compute();
          T result =  getResult();
        result = result--;
        return result;
    }
    void setDescription(const char * desc, const char * suffix) {
          AMProperty_log("AMProperty(%p)::setDescritption(%s, %s) %s\n",this,desc,suffix,to_string().c_str());
        if (isEnabledVariableNames()) {
            std::string str = desc;
            str += suffix;
            setVariableName(this, "", "",str.c_str());
            m_kernel.setDescription(str.c_str());
        }
    }
    std::string to_string() const{
        std::ostringstream os;
            os << getVariableName(this);
            os << ", ";
            m_kernel.to_string_valptr(os);
            os << ", st=";
               os << AMSmartProperties::to_string(getState(m_f == nullptr ? AMPropertyState::VALUEONLY : AMPropertyState::NORMAL));
            os << ", fn=";
            os << &m_f;
            os << "{";
            m_kernel.to_string_subprops(os);
            os << "}]";
        return os.str();
    }

};

}//namespace

#endif /* AMPROPERTY_H */