ScopeValue.h

#pragma once

#include "ScopeValueBase.h"
#include "ScopeDatatypes.h"
#include "ScopeException.h"

namespace scope {

template<class T>
class ScopeValue
    : virtual public ScopeValueBase {

protected:
    T value;

protected:
    virtual inline T CoerceValue(const T& v) const { return v; }

public:
    ScopeValue(const T& _value = T(0), const std::wstring& _name = L"None")
        :ScopeValueBase(_name)
        , value(_value) {
    }

    ScopeValue& operator=(const ScopeValue& v) {
        // Avoid self-assignment
        if ( this != &v )
            Set(v.Value(), true, true, false);
        // assign name and rw state (after we have set the value)
        ScopeValueBase::operator=(v);
        return *this;
    }

    ScopeValue& operator=(const T& v) {
        Set(v, true, true, false);
        return *this;
    }

    T Value() const {
        std::lock_guard<std::mutex> lock(mutex);
        return value;
    }

    T operator() () const {
        return Value();
    }

    operator T() const {
        return Value();
    }

    virtual T Set(const T& _v, const bool& _callguisignal = true, const bool& _callothersignal = true, const bool& _callatnochange = false) {
        T tmp;
        bool changed = false;
        // protected
        {
            std::lock_guard<std::mutex> lock(mutex);
            // If we try to set while onyl read access return immediately
            if ( !readwrite )
                return value;
            // Check if value is actually changed
            if ( value != _v ) {
                changed = true;
                value = CoerceValue(_v);
            }
            // keep the value for later outside the protected area
            tmp = value;
        }
        // call signals after unlocking the mutex to avoid possible deadlock!
        // Since signals2 is thread-safe we do not have to protect call to signal methods with a mutex.
        // avoid calling when variable was not changed unless desired.
        if ( changed || _callatnochange) {
            if ( _callguisignal )
                changesiggui();
            if ( _callothersignal )
                changesigother();
        }
        return tmp;
    }

    void SetFromString(const std::wstring& str);

    std::wstring ToChar() const;

    void AddToPropertyTree(boost::property_tree::wptree& pt) const {
        pt.add<std::wstring>(Name(), ToChar());
    }

    void SetFromPropertyTree(const boost::property_tree::wptree& pt) {
        try {
            SetFromString(pt.get<std::wstring>(Name()));
        }   // catch if we did not find this ScopeValue in the property tree
        catch (...) {
            ScopeExceptionHandler(__FUNCTION__, true, true);
        }
    }
};

}