comparisons.hpp

Go to the documentation of this file.

#ifndef SANISIZER_COMPARISONS_HPP
#define SANISIZER_COMPARISONS_HPP
 
#include "utils.hpp"
#include "generics.hpp"
 
namespace sanisizer {
 
// A little wrapper for convenience.
template<typename Integer_>
constexpr auto as_unsigned(Integer_ x) {
    static_assert(std::is_integral<Integer_>::value);
    if constexpr(std::is_unsigned<Integer_>::value) {
        return x;
    } else {
        return static_cast<typename std::make_unsigned<Integer_>::type>(x);
    }
}
template<typename Left_, typename Right_>
constexpr bool is_equal(Left_ left, Right_ right) {
    return as_unsigned(get_value(left)) == as_unsigned(get_value(right));
}
 
template<typename Left_, typename Right_>
constexpr bool is_less_than(Left_ left, Right_ right) {
    return as_unsigned(get_value(left)) < as_unsigned(get_value(right));
}
 
template<typename Left_, typename Right_>
constexpr bool is_less_than_or_equal(Left_ left, Right_ right) {
    return as_unsigned(get_value(left)) <= as_unsigned(get_value(right));
}
 
template<typename Left_, typename Right_>
constexpr bool is_greater_than(Left_ left, Right_ right) {
    return as_unsigned(get_value(left)) > as_unsigned(get_value(right));
}
 
template<typename Left_, typename Right_>
constexpr bool is_greater_than_or_equal(Left_ left, Right_ right) {
    return as_unsigned(get_value(left)) >= as_unsigned(get_value(right));
}
 
template<typename First_, typename Second_>
constexpr auto min(First_ first, Second_ second) {
    const auto fval = get_value(first);
    const auto sval = get_value(second);
    const bool first_larger = as_unsigned(fval) > as_unsigned(sval);
 
    if constexpr(as_unsigned(get_max<I<decltype(fval)> >()) > as_unsigned(get_max<I<decltype(sval)> >())) {
        if (first_larger) {
            return sval;
        } else {
            return static_cast<I<decltype(sval)> >(fval);
        }
    } else {
        if (first_larger) {
            return static_cast<I<decltype(fval)> >(sval);
        } else {
            return fval;
        }
    }
}
 
template<typename First_, typename Second_>
constexpr auto max(First_ first, Second_ second) {
    const auto fval = get_value(first);
    const auto sval = get_value(second);
    const bool first_larger = as_unsigned(fval) > as_unsigned(sval);
 
    if constexpr(as_unsigned(get_max<I<decltype(fval)> >()) > as_unsigned(get_max<I<decltype(sval)> >())) {
        if (first_larger) {
            return fval;
        } else {
            return static_cast<I<decltype(fval)> >(sval);
        }
    } else {
        if (first_larger) {
            return static_cast<I<decltype(sval)> >(fval);
        } else {
            return sval;
        }
    }
}
 
}
 
#endif