ScopeNumber.h

#pragma once

#include "ScopeValue.h"

namespace scope {

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

protected:
    T lowerLimit;

    T upperLimit;
    
    inline T CoerceValue(const T& v) const override { 
        return( ( v < lowerLimit ) ? lowerLimit : ( v > upperLimit ? upperLimit : v ) );
    }

public:
    ScopeNumber(const T& _v = 0, const T& _ll = 0, const T& _ul = 0, const std::wstring& _name = L"None")
        : ScopeValueBase(_name) {
        SetWithLimits(_v, _ll, _ul);
    }

    ScopeNumber(const ScopeNumber<T>& orig)
        : ScopeValueBase(orig.Name()) {
        SetWithLimits(orig.Value(), orig.ll(), orig.ul());
    }

    ScopeNumber& operator=(const ScopeNumber<T>& v) {
        // avoid self assignment (leads to deadlock)
        if ( this != &v )
            SetWithLimits(v.Value(), v.ll(), v.ul());
        // assign name and rw state (after we have set the value)
        ScopeValueBase::operator=(v);
        return *this;
    }

    ScopeNumber& operator=(const T& v) {
        Set(v);
        return *this;
    }

    ScopeNumber& operator+=(const ScopeNumber<T>& v) {
        Set(Value()+v.Value());
        return *this;
    }

    ScopeNumber& operator+=(const T& _val) {
        Set(Value()+_val);
        return *this;
    }

    ScopeNumber& operator-=(const ScopeNumber<T>& v) {
        Set(Value()-v.Value());
        return *this;
    }

    ScopeNumber& operator-=(const T& _val) {
        Set(Value()-_val);
        return *this;
    }

    ScopeNumber& operator*=(const ScopeNumber<T>& v) {
        Set(Value()*v.Value());
        return *this;
    }

    ScopeNumber& operator*=(const T& _val) {
        Set(Value()*_val);
        return *this;
    }

    ScopeNumber& operator/=(const ScopeNumber<T>& v) {
        Set(Value()/v.Value());
        return *this;
    }

    ScopeNumber& operator/=(const T& _val) {
        Set(Value()/_val);
        return *this;
    }

    ScopeNumber operator+(const ScopeNumber<T>& v) const { return ScopeNumber(*this) += v; }
    ScopeNumber operator-(const ScopeNumber<T>& v) const { return ScopeNumber(*this) -= v; }
    ScopeNumber operator*(const ScopeNumber<T>& v) const { return ScopeNumber(*this) *= v; }
    ScopeNumber operator/(const ScopeNumber<T>& v) const { return ScopeNumber(*this) /= v; }

    ScopeNumber operator+(const T& _val) const { return ScopeNumber(*this) += _val; }
    ScopeNumber operator-(const T& _val) const { return ScopeNumber(*this) -= _val; }
    ScopeNumber operator*(const T& _val) const { return ScopeNumber(*this) *= _val; }
    ScopeNumber operator/(const T& _val) const { return ScopeNumber(*this) /= _val; }
    bool operator<(const ScopeNumber<T>& r) const {
        return ( Value() < r.Value() );
    }

    bool operator<(const T& r) const {
        return ( Value() < r );
    }

    bool operator>(const ScopeNumber<T>& r) const {
        return ( Value() > r.Value() );
    }

    bool operator>(const T& r) const {
        return ( Value() > r );
    }

    bool operator==(const ScopeNumber<T>& r) const {
        return ( Value() == r.Value() );
    }

    /*bool operator==(T r) {            // Bug? does not compile (see here: http://www.windows-api.com/microsoft/C/35711014/enum-operator-overload-ambiguity.aspx)
        return ( Value() == r );
    }*/

    bool operator!=(const ScopeNumber<T>& r) const {
        return !(operator==(r));
    }

    /* bool operator!=(const T& r) {
        return !(operator==(r));
    }*/
    T ll() const {
        std::lock_guard<std::mutex> lock(mutex);
        return lowerLimit;
    }

    T ul() const {
        std::lock_guard<std::mutex> lock(mutex);
        return upperLimit;
    }

    T SetWithLimits(const T& v, const T& ll, const T& ul) {
        SetLimits(ll, ul);
        return Set(v);
    }

    T SetLimits(const T& _ll, const T& _ul, const bool& _callguisignal = true, const bool& _callothersignal = true, const bool& _callatnochange = false) {
        T tmp(value);
        bool changed = false;
        if ( readwrite ) {
            std::lock_guard<std::mutex> lock(mutex);
            lowerLimit = ( ( _ll < _ul ) ? _ll : _ul );
            upperLimit = ( ( _ll < _ul ) ? _ul : _ll );
            value = CoerceValue(value);
            changed = (tmp != value);
            // keep the (now possibly changed) value for later outside the protected area
            tmp = value;
        }
        // Following code had to be copied from ScopeValue
        // 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;
    }
};

}