BoundedValue.hpp

Go to the documentation of this file.

// <BoundedValue.hpp>  -*- C++ -*-
 
 
#pragma once
 
#include <iostream>
#include <limits>
#include <algorithm>
#include <type_traits>
 
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/utils/MetaStructs.hpp"
 
namespace sparta{
namespace utils{
 
template<typename T>
class BoundedValue{
public:
    using value_type = T;
    template<typename U>
    using pure_value_t = MetaStruct::decay_t<U>;
 
    template<typename U, typename V = T, typename W = T>
    explicit BoundedValue(U value,
                          V lower_bound = std::numeric_limits<T>::min(),
                          W upper_bound = std::numeric_limits<T>::max(),
                          MetaStruct::enable_if_t<MetaStruct::all_are_integral<T, U, V, W>::value and
                                                  MetaStruct::all_same_sign<T, U, V, W>::value>* = 0) :
        value_{static_cast<pure_value_t<T>>(value)},
        lower_bound_{static_cast<pure_value_t<T>>(lower_bound)},
        upper_bound_{static_cast<pure_value_t<T>>(upper_bound)}{
        // Sanity checks.
        sparta_assert(upper_bound > lower_bound);
        // TODO how can you be a value lower than the min() value for a type?
        //sparta_assert(lower_bound >= std::numeric_limits<T>::min());
        sparta_assert(upper_bound <= std::numeric_limits<T>::max());
 
        // Range check.
        checkRange_(value);
    }
 
    template<typename U, typename V = T, typename W = T>
    explicit BoundedValue(U value,
                          V lower_bound = std::numeric_limits<T>::min(),
                          W upper_bound = std::numeric_limits<T>::max(),
                          MetaStruct::enable_if_t<MetaStruct::all_are_integral<T, U, V, W>::value and
                                                  std::is_unsigned<pure_value_t<T>>::value        and
                                                  std::is_signed<pure_value_t<U>>::value          and
                                                  std::is_unsigned<pure_value_t<V>>::value        and
                                                  std::is_unsigned<pure_value_t<W>>::value>* = 0) :
        value_{static_cast<pure_value_t<T>>(value)},
        lower_bound_{static_cast<pure_value_t<T>>(lower_bound)},
        upper_bound_{static_cast<pure_value_t<T>>(upper_bound)}{
        // Sanity checks.
        sparta_assert(value >= 0);
        sparta_assert(static_cast<uintmax_t>(lower_bound) >=
                    static_cast<uintmax_t>(std::numeric_limits<T>::min()));
        sparta_assert(static_cast<uintmax_t>(upper_bound) <=
                    static_cast<uintmax_t>(std::numeric_limits<T>::max()));
        sparta_assert(static_cast<uintmax_t>(upper_bound) > static_cast<uintmax_t>(lower_bound));
 
        // Range check.
        checkRange_(value);
    }
 
    template<typename U, typename V = T, typename W = T>
    explicit BoundedValue(U value,
                          V lower_bound = std::numeric_limits<T>::min(),
                          W upper_bound = std::numeric_limits<T>::max(),
                          MetaStruct::enable_if_t<MetaStruct::all_are_integral<T, U, V, W>::value and
                                                  std::is_unsigned<pure_value_t<T>>::value        and
                                                  std::is_unsigned<pure_value_t<U>>::value        and
                                                  (std::is_signed<pure_value_t<V>>::value         or
                                                  std::is_signed<pure_value_t<W>>::value)>* = 0) :
        value_{static_cast<pure_value_t<T>>(value)},
        lower_bound_{static_cast<pure_value_t<T>>(lower_bound)},
        upper_bound_{static_cast<pure_value_t<T>>(upper_bound)}{
        // Sanity checks.
        sparta_assert(lower_bound >= 0 and
                    static_cast<uintmax_t>(lower_bound) >=
                    static_cast<uintmax_t>(std::numeric_limits<T>::min()));
        sparta_assert(upper_bound >= 0 and
                    static_cast<uintmax_t>(upper_bound) <=
                    static_cast<uintmax_t>(std::numeric_limits<T>::max()));
        sparta_assert(static_cast<uintmax_t>(upper_bound) > static_cast<uintmax_t>(lower_bound));
 
        // Range check.
        checkRange_(value);
    }
 
    template<typename U, typename V = T, typename W = T>
    explicit BoundedValue(U value,
                          V lower_bound = std::numeric_limits<T>::min(),
                          W upper_bound = std::numeric_limits<T>::max(),
                          MetaStruct::enable_if_t<MetaStruct::all_are_integral<T, U, V, W>::value and
                                                  std::is_unsigned<pure_value_t<T>>::value        and
                                                  std::is_signed<pure_value_t<U>>::value          and
                                                  (std::is_signed<pure_value_t<V>>::value         or
                                                  std::is_signed<pure_value_t<W>>::value)>* = 0) :
        value_{static_cast<pure_value_t<T>>(value)},
        lower_bound_{static_cast<pure_value_t<T>>(lower_bound)},
        upper_bound_{static_cast<pure_value_t<T>>(upper_bound)}{
        // Sanity checks.
        sparta_assert(value >= 0);
        sparta_assert(lower_bound >= 0 and
                    static_cast<uintmax_t>(lower_bound) >=
                    static_cast<uintmax_t>(std::numeric_limits<T>::min()));
        sparta_assert(upper_bound >= 0 and
                    static_cast<uintmax_t>(upper_bound) <=
                    static_cast<uintmax_t>(std::numeric_limits<T>::max()));
        sparta_assert(static_cast<uintmax_t>(upper_bound) > static_cast<uintmax_t>(lower_bound));
 
        // Range check.
        checkRange_(value);
    }
 
    template<typename U, typename V = T, typename W = T>
    explicit BoundedValue(U value,
                          V lower_bound = std::numeric_limits<T>::min(),
                          W upper_bound = std::numeric_limits<T>::max(),
                          MetaStruct::enable_if_t<MetaStruct::all_are_integral<T, U, V, W>::value and
                                                  std::is_signed<pure_value_t<T>>::value          and
                                                  std::is_unsigned<pure_value_t<U>>::value        and
                                                  std::is_signed<pure_value_t<V>>::value          and
                                                  std::is_signed<pure_value_t<W>>::value>* = 0) :
        value_{static_cast<pure_value_t<T>>(value)},
        lower_bound_{static_cast<pure_value_t<T>>(lower_bound)},
        upper_bound_{static_cast<pure_value_t<T>>(upper_bound)}{
        // Sanity checks.
        sparta_assert(static_cast<intmax_t>(lower_bound) >= static_cast<intmax_t>(std::numeric_limits<T>::min()));
        sparta_assert(static_cast<intmax_t>(upper_bound) <= static_cast<intmax_t>(std::numeric_limits<T>::max()));
        sparta_assert(static_cast<intmax_t>(upper_bound) > static_cast<intmax_t>(lower_bound));
        sparta_assert(static_cast<uintmax_t>(value) <= static_cast<uintmax_t>(std::numeric_limits<T>::max()));
 
        // Range check.
        checkRange_(value);
    }
 
    template<typename U, typename V = T, typename W = T>
    explicit BoundedValue(U value,
                          V lower_bound = std::numeric_limits<T>::min(),
                          W upper_bound = std::numeric_limits<T>::max(),
                          MetaStruct::enable_if_t<MetaStruct::all_are_integral<T, U, V, W>::value and
                                                  std::is_signed<pure_value_t<T>>::value          and
                                                  std::is_signed<pure_value_t<U>>::value          and
                                                  (std::is_unsigned<pure_value_t<V>>::value       or
                                                  std::is_unsigned<pure_value_t<W>>::value)>* = 0) :
        value_{static_cast<pure_value_t<T>>(value)},
        lower_bound_{static_cast<pure_value_t<T>>(lower_bound)},
        upper_bound_{static_cast<pure_value_t<T>>(upper_bound)}{
        // Sanity checks.
        if(lower_bound < 0){
            sparta_assert(static_cast<intmax_t>(lower_bound) >=
                        static_cast<intmax_t>(std::numeric_limits<T>::min()));
        }
        if(upper_bound > 0){
            sparta_assert(static_cast<uintmax_t>(upper_bound) <=
                        static_cast<uintmax_t>(std::numeric_limits<T>::max()));
        }
        if(upper_bound > 0 and lower_bound > 0){
            sparta_assert(static_cast<uintmax_t>(upper_bound) > static_cast<uintmax_t>(lower_bound));
        }
 
        // Range check.
        checkRange_(value);
    }
 
    template<typename U, typename V = T, typename W = T>
    explicit BoundedValue(U value,
                          V lower_bound = std::numeric_limits<T>::min(),
                          W upper_bound = std::numeric_limits<T>::max(),
                          MetaStruct::enable_if_t<MetaStruct::all_are_integral<T, U, V, W>::value and
                                                  std::is_signed<pure_value_t<T>>::value          and
                                                  std::is_unsigned<pure_value_t<U>>::value        and
                                                  (std::is_unsigned<pure_value_t<V>>::value       or
                                                  std::is_unsigned<pure_value_t<W>>::value)>* = 0) :
        value_{static_cast<pure_value_t<T>>(value)},
        lower_bound_{static_cast<pure_value_t<T>>(lower_bound)},
        upper_bound_{static_cast<pure_value_t<T>>(upper_bound)}{
        // Sanity checks.
        if(lower_bound < 0){
            sparta_assert(static_cast<intmax_t>(lower_bound) >=
                        static_cast<intmax_t>(std::numeric_limits<T>::min()));
        }
        if(upper_bound > 0){
            sparta_assert(static_cast<uintmax_t>(upper_bound) <=
                        static_cast<uintmax_t>(std::numeric_limits<T>::max()));
        }
        if(upper_bound > 0 and lower_bound > 0){
            sparta_assert(static_cast<uintmax_t>(upper_bound) > static_cast<uintmax_t>(lower_bound));
        }
 
        // Range check.
        checkRange_(value);
    }
 
    template<typename U, typename V = T, typename W = T>
    explicit BoundedValue(U value,
                          V lower_bound = std::numeric_limits<T>::min(),
                          W upper_bound = std::numeric_limits<T>::max(),
                          MetaStruct::enable_if_t<std::is_integral<pure_value_t<T>>::value        and
                                                  (std::is_floating_point<pure_value_t<U>>::value or
                                                   std::is_floating_point<pure_value_t<V>>::value or
                                                   std::is_floating_point<pure_value_t<W>>::value)>* = 0){
        (void) value;
        (void) lower_bound;
        (void) upper_bound;
 
        static_assert(!std::is_floating_point<pure_value_t<U>>::value,
                      "Cannot assign a floating-point limit to integral BoundedValue.");
        static_assert(!std::is_floating_point<pure_value_t<V>>::value,
                      "Cannot assign a floating-point limit to integral BoundedValue.");
        static_assert(!std::is_floating_point<pure_value_t<W>>::value,
                      "Cannot assign a floating-point limit to integral BoundedValue.");
    }
 
    template<typename U>
    BoundedValue(const BoundedValue<U>& rhs,
                 MetaStruct::enable_if_t<std::is_integral<pure_value_t<U>>::value and
                                         std::is_signed<pure_value_t<T>>::value ==
                                         std::is_signed<pure_value_t<U>>::value>* = 0) :
        value_{static_cast<pure_value_t<T>>(rhs.getValue())},
        lower_bound_{static_cast<pure_value_t<T>>(rhs.getLowerBound())},
        upper_bound_{static_cast<pure_value_t<T>>(rhs.getUpperBound())}{
 
        // Sanity checks.
        sparta_assert(rhs.getLowerBound() >= std::numeric_limits<T>::min());
        sparta_assert(rhs.getUpperBound() <= std::numeric_limits<T>::max());
    }
 
    template<typename U>
    BoundedValue(const BoundedValue<U>& rhs,
                 MetaStruct::enable_if_t<std::is_integral<pure_value_t<U>>::value and
                                         std::is_signed<pure_value_t<T>>::value and
                                         std::is_unsigned<pure_value_t<U>>::value>* = 0) :
        value_{static_cast<pure_value_t<T>>(rhs.getValue())},
        lower_bound_{static_cast<pure_value_t<T>>(rhs.getLowerBound())},
        upper_bound_{static_cast<pure_value_t<T>>(rhs.getUpperBound())}{
 
        // Sanity check.
        sparta_assert(rhs.getUpperBound() <= static_cast<U>(std::numeric_limits<T>::max()));
    }
 
    template<typename U>
    BoundedValue(const BoundedValue<U>& rhs,
                 MetaStruct::enable_if_t<std::is_integral<pure_value_t<U>>::value and
                                         std::is_unsigned<pure_value_t<T>>::value and
                                         std::is_signed<pure_value_t<U>>::value>* = 0) :
        value_{static_cast<pure_value_t<T>>(rhs.getValue())},
        lower_bound_{static_cast<pure_value_t<T>>(rhs.getLowerBound())},
        upper_bound_{static_cast<pure_value_t<T>>(rhs.getUpperBound())}{
 
        // Sanity checks.
        sparta_assert(rhs.getValue() >= 0);
        sparta_assert(rhs.getLowerBound() >= 0 and
                    static_cast<T>(rhs.getLowerBound()) >= std::numeric_limits<T>::min());
        sparta_assert(rhs.getUpperBound() >= 0 and
                    static_cast<T>(rhs.getUpperBound()) <= std::numeric_limits<T>::max());
    }
 
    template<typename U>
    BoundedValue(const BoundedValue<U>& rhs,
                 MetaStruct::enable_if_t<std::is_floating_point<pure_value_t<U>>::value and
                                         std::is_integral<pure_value_t<T>>::value>* = 0){
        (void)rhs;
        static_assert(std::is_floating_point<pure_value_t<T>>::value,
                      "Cannot assign a floating-point BoundedValue to integral BoundedValue.");
    }
 
    template<typename U>
    MetaStruct::enable_if_t<std::is_integral<pure_value_t<U>>::value and
                            std::is_signed<pure_value_t<T>>::value ==
                            std::is_signed<pure_value_t<U>>::value,
                            BoundedValue<pure_value_t<T>>&>
    operator = (const BoundedValue<U>& rhs){
        // Sanity checks.
        sparta_assert(rhs.getLowerBound() >= std::numeric_limits<T>::min());
        sparta_assert(rhs.getUpperBound() <= std::numeric_limits<T>::max());
 
        value_ = static_cast<pure_value_t<T>>(rhs.getValue());
        lower_bound_ = static_cast<pure_value_t<T>>(rhs.getLowerBound());
        upper_bound_ = static_cast<pure_value_t<T>>(rhs.getUpperBound());
        return *this;
    }
 
    template<typename U>
    MetaStruct::enable_if_t<std::is_integral<pure_value_t<U>>::value and
                            std::is_signed<pure_value_t<T>>::value and
                            std::is_unsigned<pure_value_t<U>>::value,
                            BoundedValue<pure_value_t<T>>&>
    operator = (const BoundedValue<U>& rhs){
        // Sanity checks.
        sparta_assert(rhs.getUpperBound() <= static_cast<U>(std::numeric_limits<T>::max()));
 
        value_ = static_cast<pure_value_t<T>>(rhs.getValue());
        lower_bound_ = static_cast<pure_value_t<T>>(rhs.getLowerBound());
        upper_bound_ = static_cast<pure_value_t<T>>(rhs.getUpperBound());
        return *this;
    }
 
    template<typename U>
    MetaStruct::enable_if_t<std::is_integral<pure_value_t<U>>::value and
                            std::is_signed<pure_value_t<U>>::value and
                            std::is_unsigned<pure_value_t<T>>::value,
                            BoundedValue<pure_value_t<T>>&>
    operator = (const BoundedValue<U>& rhs){
        // Sanity checks.
        sparta_assert(rhs.getValue() >= 0);
        sparta_assert(rhs.getLowerBound() >= 0 and
                    static_cast<T>(rhs.getLowerBound()) >= std::numeric_limits<T>::min());
        sparta_assert(rhs.getUpperBound() >= 0 and
                    static_cast<T>(rhs.getUpperBound()) <= std::numeric_limits<T>::max());
 
        value_ = static_cast<pure_value_t<T>>(rhs.getValue());
        lower_bound_ = static_cast<pure_value_t<T>>(rhs.getLowerBound());
        upper_bound_ = static_cast<pure_value_t<T>>(rhs.getUpperBound());
        return *this;
    }
 
    template<typename U>
    MetaStruct::enable_if_t<std::is_floating_point<pure_value_t<U>>::value and
                            std::is_integral<pure_value_t<T>>::value,
                            void>
    operator = (const BoundedValue<U>& rhs){
        (void)rhs;
        static_assert(std::is_floating_point<pure_value_t<T>>::value,
                      "Cannot assign a floating-point BoundedValue to integral BoundedValue.");
    }
 
    template<typename U>
    MetaStruct::enable_if_t<std::is_integral<pure_value_t<U>>::value,
                            BoundedValue<pure_value_t<T>>&>
    operator = (U value){
        checkRange_(value);
        value_ = static_cast<pure_value_t<T>>(value);
        return *this;
    }
 
    template<typename U>
    MetaStruct::enable_if_t<std::is_floating_point<pure_value_t<U>>::value and
                            std::is_integral<pure_value_t<T>>::value,
                            void>
    operator = (U value){
        (void)value;
        static_assert(std::is_floating_point<pure_value_t<T>>::value,
                      "Cannot assign a floating-point number to integral BoundedValue.");
    }
 
    BoundedValue<T>& operator++(){
        sparta_assert(value_ < upper_bound_);
        checkRange_(value_ + 1);
        ++value_;
        return *this;
    }
 
    BoundedValue<T> operator++(int){
        BoundedValue<T> copy(*this);
        ++(*this);
        return copy;
    }
 
    BoundedValue<T>& operator--(){
        sparta_assert(value_ > lower_bound_);
        checkRange_(value_ - 1);
        --value_;
        return *this;
    }
 
    BoundedValue<T> operator--(int){
        BoundedValue<T> copy(*this);
        --(*this);
        return copy;
    }
 
    template<typename U = T>
    MetaStruct::enable_if_t<std::is_integral<pure_value_t<U>>::value, BoundedValue<T>&>
    operator+=(U value){
        if(value >= 0){
            const auto remaining = upper_bound_ - value_;
            sparta_assert(static_cast<uintmax_t>(remaining) >= static_cast<uintmax_t>(value),
                        "Adding the right hand side value would violate the upper-bound of this BV.");
            value_ += value;
            return *this;
        }
        const auto remaining = value_ - lower_bound_;
        sparta_assert(static_cast<uintmax_t>(-value) <= static_cast<uintmax_t>(remaining),
                    "Adding the right hand side value would violate the lower-bound of this BV.");
        value_ += value;
        return *this;
    }
 
    template<typename U = T>
    MetaStruct::enable_if_t<std::is_integral<pure_value_t<U>>::value, BoundedValue<T>&>
    operator-=(U value){
        if(value >= 0){
            const auto remaining = value_ - lower_bound_;
            sparta_assert(static_cast<uintmax_t>(remaining) >= static_cast<uintmax_t>(value),
                        "Deducting the right hand side value would violate the lower-bound of this BV.");
            value_ -= value;
            return *this;
        }
        const auto remaining = upper_bound_ - value_;
        sparta_assert(static_cast<uintmax_t>(-value) <= static_cast<uintmax_t>(remaining),
                    "Deducting the right hand side value would violate the upper-bound of this BV.");
        value_ -= value;
        return *this;
    }
 
    const value_type getValue() const{
        return value_;
    }
 
    value_type getValue(){
        return value_;
    }
 
    const value_type getLowerBound() const{
        return lower_bound_;
    }
 
    value_type getLowerBound(){
        return lower_bound_;
    }
 
    const value_type getUpperBound() const{
        return upper_bound_;
    }
 
    value_type getUpperBound(){
        return upper_bound_;
    }
 
    operator const value_type& () const{
        return value_;
    }
 
    operator value_type& (){
        return value_;
    }
private:
    T value_;
    T lower_bound_;
    T upper_bound_;
 
    template<typename U>
    void checkRange_(const U & value) const{
        checkLowerBound_<U>(value);
        checkUpperBound_<U>(value);
    }
 
    template<typename U>
    MetaStruct::enable_if_t<std::is_signed<pure_value_t<U>>::value ==
                            std::is_signed<pure_value_t<T>>::value, void>
    checkLowerBound_(const U& value) const{
        sparta_assert(value >= lower_bound_);
    }
 
    template<typename U>
    MetaStruct::enable_if_t<std::is_unsigned<pure_value_t<U>>::value and
                            std::is_signed<pure_value_t<T>>::value, void>
    checkLowerBound_(const U& value) const{
        if(lower_bound_ >= 0){
            sparta_assert(value >= static_cast<uintmax_t>(lower_bound_));
        }
    }
 
    template<typename U>
    MetaStruct::enable_if_t<std::is_signed<pure_value_t<U>>::value and
                            std::is_unsigned<pure_value_t<T>>::value, void>
    checkLowerBound_(const U& value) const{
        sparta_assert((value >= 0) && (static_cast<uintmax_t>(value) >= lower_bound_));
    }
 
    template<typename U>
    MetaStruct::enable_if_t<std::is_signed<pure_value_t<U>>::value ==
                            std::is_signed<pure_value_t<T>>::value, void>
    checkUpperBound_(const U& value) const{
        sparta_assert(value <= upper_bound_);
    }
 
    template<typename U>
    MetaStruct::enable_if_t<std::is_unsigned<pure_value_t<U>>::value and
                            std::is_signed<T>::value, void>
    checkUpperBound_(const U& value) const{
        sparta_assert((upper_bound_ >= 0) && (value <= static_cast<uintmax_t>(upper_bound_)));
    }
 
    template<typename U>
    MetaStruct::enable_if_t<std::is_signed<pure_value_t<U>>::value and
                            std::is_unsigned<pure_value_t<T>>::value, void>
    checkUpperBound_(const U& value) const{
        sparta_assert((value >= 0) && (static_cast<uintmax_t>(value) <= upper_bound_));
    }
};
 
template<typename T>
inline std::ostream & operator << (std::ostream & os,
                                   const sparta::utils::BoundedValue<T> & data){
    os << data.getValue();
    return os;
}
}
}