Bounded.hpp

Go to the documentation of this file.

#ifndef SANISIZER_BOUNDED_HPP
#define SANISIZER_BOUNDED_HPP
 
#include <type_traits>
#include <cassert>
#include <stdexcept>
 
#include "utils.hpp"
 
namespace sanisizer {
 
template<typename Integer_, Integer_ max_>
struct Bounded {
    static_assert(std::is_integral<Integer_>::value);
    static_assert(max_ >= 0);
 
    constexpr Bounded(Integer_ x) : value(x) {
        assert(x <= max_);
    }
 
    typedef Integer_ Integer;
 
    static constexpr Integer_ max = max_;
 
    Integer_ value;
};
 
template<typename Value_>
struct is_Bounded {
    static constexpr bool value = false;
};
 
template<typename Integer_, Integer_ max_>
struct is_Bounded<Bounded<Integer_, max_> > {
    static constexpr bool value = true;
};
 
// Avoid issues with constness.
template<typename Integer_, Integer_ max_>
struct is_Bounded<const Bounded<Integer_, max_> > {
    static constexpr bool value = true;
}; 
 
// Declarations below.
template<typename Value_>
constexpr auto get_value(const Value_);
 
template<typename Value_>
constexpr auto get_max();
 
template<typename Left_, typename Right_>
constexpr bool is_greater_than(Left_, Right_);
 
// Internal function.
template<bool safe_, typename Max_, Max_ new_max_, typename Value_>
constexpr auto set_bound_internal(Value_ x) {
    if constexpr(is_greater_than(get_max<Value_>(), new_max_)) {
        const auto val = get_value(x);
        if constexpr(safe_) {
            if (is_greater_than(val, new_max_)) {
                throw std::domain_error("input value exceeds the declared upper bound");
            }
        }
        return Bounded<I<decltype(val)>, new_max_>(val);
    } else {
        return x; 
    }
}
template<typename Max_, Max_ new_max_, typename Value_>
constexpr auto set_bound(Value_ x) {
    return set_bound_internal<true, Max_, new_max_>(x);
}
 
template<typename MaxType_, typename Value_>
constexpr auto set_bound_by_type(Value_ x) {
    return set_bound<MaxType_, get_max<MaxType_>()>(x);
}
 
template<typename Max_, Max_ new_max_, typename Value_>
constexpr auto set_bound_unsafe(Value_ x) {
    return set_bound_internal<false, Max_, new_max_>(x);
}
 
template<typename MaxType_, typename Value_>
constexpr auto set_bound_by_type_unsafe(Value_ x) {
    return set_bound<MaxType_, get_max<MaxType_>()>(x);
}
 
// Back-compatibility.
template<typename Integer_, Integer_ max_>
using Attestation = Bounded<Integer_, max_>;
 
template<typename ... Args_>
using is_Attestation = is_Bounded<Args_...>;
 
template<typename Max_, Max_ new_max_, typename Value_>
constexpr auto attest_max(Value_ x) { return set_bound<Max_, new_max_, Value_>(x); }
 
template<typename MaxType_, typename Value_>
constexpr auto attest_max_by_type(Value_ x) { return set_bound_by_type<MaxType_, Value_>(x); }
 
template<typename Value_>
Value_ attest_gez(Value_ x) { return x; }
}
 
#endif