ValidValue.hpp

Go to the documentation of this file.

// <Port> -*- C++ -*-
 
 
#pragma once
 
#include <iostream>
#include "sparta/utils/SpartaAssert.hpp"
 
namespace sparta
{
namespace utils
{
 
    template <typename T>
    class ValidValue
    {
    public:
        typedef T value_type;
 
        ValidValue() :
            valid_(false),
            value_()
        {}
 
        template<typename ...ArgsT>
        ValidValue(ArgsT&& ...args) :
            valid_(true),
            value_(std::forward<ArgsT>(args)...)
        {}
 
        ValidValue(ValidValue &) = default;
 
        ValidValue(ValidValue && v) :
            valid_(v.valid_),
            value_(std::move(v.value_))
        {
            v.valid_ = false;
        }
 
        ValidValue(const ValidValue &) = default;
 
        ValidValue & operator=(const ValidValue&) = default;
        ValidValue & operator=(ValidValue&&) = default;
 
        value_type operator=(const value_type & val) {
            valid_ = true;
            return (value_ = val);
        }
 
        value_type operator=(value_type && val) {
            valid_ = true;
            return (value_ = std::move(val));
        }
 
        bool operator==(const value_type & val) const {
            sparta_assert(valid_ == true, "ValidValue is not valid for compare!");
            return (value_ == val);
        }
 
        bool operator!=(const value_type & val) const {
            return !operator==(val);
        }
 
        bool operator==(const ValidValue<T> & val) const {
            sparta_assert(valid_ == true, "ValidValue is not valid for compare!");
            return (value_ == val.value_);
        }
 
        bool operator!=(const ValidValue<T> & val) const {
            return !operator==(val);
        }
 
        bool isValid() const {
            return valid_;
        }
 
        operator const value_type &() const {
            sparta_assert(valid_ == true, "ValidValue is not valid for conversion!");
            return value_;
        }
 
        operator value_type & () {
            sparta_assert(valid_ == true, "ValidValue is not valid for conversion!");
            return value_;
        }
 
        const value_type & getValue() const {
            sparta_assert(valid_ == true, "ValidValue is not valid for getting!");
            return value_;
        }
 
        value_type & getValue() {
            sparta_assert(valid_ == true, "ValidValue is not valid for getting!");
            return value_;
        }
 
        void clearValid() {
            valid_ = false;
        }
 
        template <typename Archive>
        void serialize(Archive & ar, const unsigned int /* version */) {
            // The operator& here is a reader/writer for the member variable RHS.
            // We should always read and write the valid_ flag, but only do the
            // same for value_ when valid.
            ar & valid_;
            if (valid_)
            {
                ar & value_;
            }
        }
 
    private:
        bool valid_ = false;  
        value_type value_;    
    };
 
template<class ValidValT>
std::ostream & operator<<(std::ostream & os, const sparta::utils::ValidValue<ValidValT> & vv)
{
    if(vv.isValid()) {
        os << vv.getValue();
    }
    else {
        os << "<invalid ValidValue>";
    }
    return os;
}
}
}