ScopeValueBase.h

#pragma once

namespace scope {

class ScopeValueBase {

protected:
    std::wstring name;

    mutable std::mutex mutex;

    bool readwrite;

    typedef boost::signals2::signal<void ()> signalchange_t;

    typedef boost::signals2::signal<void (bool)> signalstate_t;

    signalchange_t changesiggui;

    signalchange_t changesigother;

    signalstate_t statesig;

public:
    ScopeValueBase(const std::wstring& _name = L"None")
        : readwrite(true)
        , name(_name) {
    }

    ScopeValueBase(const ScopeValueBase& _svb)
        : readwrite(_svb.GetRWState())
        , name(_svb.Name()) {
    }

    ScopeValueBase& operator=(const ScopeValueBase& _svb) {
        // Avoid self-assignment
        if ( this != &_svb ) {
            std::lock_guard<std::mutex> lock(mutex);
            readwrite = _svb.GetRWState();
            name = _svb.Name();
        }
        return *this;
    }

    virtual ~ScopeValueBase() {
        std::lock_guard<std::mutex> lock(mutex);
        // If anything still connected now is the time to let it go...
        changesiggui.disconnect_all_slots();
        changesigother.disconnect_all_slots();
        statesig.disconnect_all_slots();
    }

    std::wstring Name() const { 
        std::lock_guard<std::mutex> lock(mutex);
        return name;
    }

    void SetName(const std::wstring& _name) {
        std::lock_guard<std::mutex> lock(mutex);
        name = _name;
    }

    void SetRWState(const bool& _state) {
        {
        std::lock_guard<std::mutex> lock(mutex);
        readwrite = _state;
        }
        statesig(_state);
    }

    bool GetRWState() const {
        std::lock_guard<std::mutex> lock(mutex);
        return readwrite;
    }

    boost::signals2::connection ConnectGUI(signalchange_t::slot_type slot) {
        // signals2 is thread-safe, we do not have to protect method calls on signals with a mutex
        return changesiggui.connect(slot);
    }

    boost::signals2::connection ConnectOther(signalchange_t::slot_type slot) {
        return changesigother.connect(slot);
    }

    boost::signals2::connection ConnectState(signalstate_t::slot_type slot) {
        return statesig.connect(slot);
    }
};

}