ValueLimiter.hpp

#ifndef VALUELIMITER_H
#define VALUELIMITER_H
 
#include <stdexcept>
#include <utility>
 
using ValueLimitType = int; 
using ValueLimitSimplePair = std::pair<ValueLimitType, ValueLimitType>; 
namespace ValueLimitUtils {
 
constexpr int minFromPair(ValueLimitSimplePair p) noexcept {
    return p.first;
}
 
constexpr int maxFromPair(ValueLimitSimplePair p) noexcept {
    return p.second;
}
 
constexpr bool inBound(ValueLimitType value, ValueLimitSimplePair p) {
    return value >= minFromPair(p) && value <= maxFromPair(p);
}
 
constexpr ValueLimitType boundWithPair(const ValueLimitType value,
                                       const ValueLimitSimplePair vp) {
    if (vp.first > vp.second)
        throw std::logic_error("boundWithPair: min > max");
    if (value < vp.first)
        return vp.first;
    if (value > vp.second)
        return vp.second;
    return value;
}
 
template <ValueLimitType MIN = 0, ValueLimitType MAX = 100>
class StaticLimiter {
    static_assert(MIN <= MAX, "MIN must be <= MAX");
 
public:
    static constexpr ValueLimitType boundValue(ValueLimitType value) {
        return value < MIN ? MIN : (value > MAX ? MAX : value);
    }
};
}
 
template <ValueLimitType MIN = 0, ValueLimitType MAX = 100>
class ValueLimiter {
public:
    ValueLimiter() = default;
 
    constexpr ValueLimiter(ValueLimitType runtime_min, ValueLimitType runtime_max) {
        setMin(runtime_min);
        setMax(runtime_max);
    }
 
    constexpr ValueLimitType getMin() const noexcept {
        return runtime_min_;
    }
 
    constexpr ValueLimitType getMax() const noexcept {
        return runtime_max_;
    }
 
    void setMin(ValueLimitType v) {
        if (v > runtime_max_)
            runtime_min_ = runtime_max_;
        else
            runtime_min_ = v;
    }
 
    void setMax(ValueLimitType v) {
        if (v < runtime_min_)
            runtime_max_ = runtime_min_;
        else
            runtime_max_ = v;
    }
 
    static constexpr ValueLimitType compileMin = MIN; 
    static constexpr ValueLimitType compileMax = MAX; 
    constexpr ValueLimitType boundValue(ValueLimitType value) const {
        if (value < runtime_min_)
            return runtime_min_;
        if (value > runtime_max_)
            return runtime_max_;
        return value;
    }
 
private:
    ValueLimitType runtime_min_ = MIN; 
    ValueLimitType runtime_max_ = MAX; 
};
 
#ifdef __BOUND_PROPERTY_GETSET
#error "__BOUND_PROPERTY_GETSET is defined, which is not allowed!"
#else
#define __BOUND_PROPERTY_GETSET(typeName, typeVar, boundary_pair)         \
    inline void set##typeVar(typeName __value) {                          \
        typeVar = ValueLimitUtils::boundWithPair(__value, boundary_pair); \
    }                                                                     \
    inline typeName get##typeVar() const {                                \
        return typeVar;                                                   \
    }
#endif
 
#ifdef __BOUND_PROPERTY_GETSET_UNALLOWED_OUTRANGE
#error "__BOUND_PROPERTY_GETSET_UNALLOWED_OUTRANGE is defined, which is not allowed!"
#else
#define __BOUND_PROPERTY_GETSET_UNALLOWED_OUTRANGE(typeName, typeVar, boundary_pair) \
    inline void set##typeVar(typeName __value) {                                     \
        if (!ValueLimitUtils::inBound(__value, boundary_pair))                       \
            throw std::overflow_error("Value you set is out ranges");                \
        typeVar = __value;                                                           \
    }                                                                                \
    inline typeName get##typeVar() const {                                           \
        return typeVar;                                                              \
    }
#endif
 
#endif // VALUELIMITER_H