LockedValue.hpp

Go to the documentation of this file.

// <LockedValue> -*- C++ -*-
 
 
#pragma once
 
#include "sparta/utils/SpartaAssert.hpp"
 
namespace sparta{
namespace utils{
template<typename T>
 
class LockedValue{
public:
    typedef T value_type;
 
    LockedValue() : is_locked_{false}, value_{}{}
 
    explicit LockedValue(const T& value) : is_locked_{false}, value_{value}{}
 
    LockedValue(const T& value, const bool lock) : is_locked_{lock}, value_{value}{}
 
    LockedValue<T>& operator = (const LockedValue<T>&) = delete;
 
    //  This asserts if the LockedValue instance is already locked.
    LockedValue<T>& operator = (const T& value){
        sparta_assert(!is_locked_,
                    "LockedValue is already locked and cannot be assigned a new value.");
        value_ = value;
        return *this;
    }
 
    //  This asserts if the LockedValue instance is already locked.
    void setAndLock(const T& value){
        sparta_assert(!is_locked_,
                    "LockedValue is already locked and cannot be set a new value.");
        value_ = value;
        is_locked_ = true;
    }
 
    void lock(){
        is_locked_ = true;
    }
 
    bool isLocked() const{
        return is_locked_;
    }
 
    //  Querying for the value should never throw, be it initialized or not.
    //  This is the const version.
    const value_type& getValue() const{
        return value_;
    }
 
    //  querying for the value should never throw, be it initialized or not.
    //  this is the non-const version.
    value_type& getValue(){
        return value_;
    }
 
    //  Converting to the value should never throw, be it initialized or not.
    //  This is the const-version.
    operator const value_type& () const{
        return value_;
    }
 
    //  Converting to the value should never throw, be it initialized or not.
    //  This is the non-const-version.
    operator value_type& (){
        return value_;
    }
 
    bool operator == (const value_type& value) const{
        return value_ == value;
    }
 
    bool operator != (const value_type& value) const{
        return !operator == (value);
    }
private:
        bool is_locked_ {false}; 
        value_type value_;       
};
 
template<class T>
std::ostream& operator << (std::ostream& os, const sparta::utils::LockedValue<T>& value){
    os << value.getValue();
    return os;
} // LockedValue
} // namespace utils
} // namespace sparta