BaseValue.h

Go to the documentation of this file.

 
#pragma once
#include "ImmutableValue.h"
#include <iosfwd>
#include <utility>
 
namespace catapult { namespace utils {
 
    template<typename TValue, typename TTag, typename TBaseValue>
    class BasicBaseValue : TTag {
    public:
        using ValueType = TValue;
 
    public:
        constexpr explicit BasicBaseValue(TValue value) : m_value(value)
        {}
 
        constexpr BasicBaseValue(const BasicBaseValue& rhs) : m_value(static_cast<TValue>(rhs.m_value))
        {}
 
    public:
        BasicBaseValue& operator=(BasicBaseValue rhs) {
            m_value = std::move(rhs.m_value);
            return *this;
        }
 
    public:
        constexpr ValueType unwrap() const {
            return m_value;
        }
 
    public:
        constexpr bool operator==(TBaseValue rhs) const {
            return m_value == rhs.m_value;
        }
 
        constexpr bool operator!=(TBaseValue rhs) const {
            return !(*this == rhs);
        }
 
        constexpr bool operator>=(TBaseValue rhs) const {
            return m_value >= rhs.m_value;
        }
 
        constexpr bool operator>(TBaseValue rhs) const {
            return m_value > rhs.m_value;
        }
 
        constexpr bool operator<=(TBaseValue rhs) const {
            return m_value <= rhs.m_value;
        }
 
        constexpr bool operator<(TBaseValue rhs) const {
            return m_value < rhs.m_value;
        }
 
        friend std::ostream& operator<<(std::ostream& out, TBaseValue baseValue) {
            out << baseValue.m_value;
            return out;
        }
 
    private:
        ImmutableValue<TValue> m_value;
    };
 
    template<typename TValue, typename TTag>
    class BaseValue : public BasicBaseValue<TValue, TTag, BaseValue<TValue, TTag>> {
    public:
        constexpr explicit BaseValue(TValue value = 0)
                : BasicBaseValue<TValue, TTag, BaseValue<TValue, TTag>>(value)
        {}
 
    public:
        constexpr BaseValue operator+(BaseValue rhs) const {
            return BaseValue(this->unwrap() + rhs.unwrap());
        }
 
        constexpr BaseValue operator-(BaseValue rhs) const {
            return BaseValue(this->unwrap() - rhs.unwrap());
        }
    };
}}