range.hpp

 
#ifndef UFO_CORE_RANGE_HPP
#define UFO_CORE_RANGE_HPP
 
// STL
#include <format>
#include <ostream>
#include <type_traits>
#include <utility>
 
namespace ufo
{
template <typename T>
struct Range {
    using value_type = T;
 
    value_type lower;
 
    value_type upper;
 
    // struct Comparator {
    //  using is_transparent = std::true_type;
 
    //  /**
    //   * @brief Interval ordering for associative containers.
    //   *
    //   * @param lhs Left operand (Range or pair).
    //   * @param rhs Right operand (Range or pair).
    //   * @return True if lhs.upper < rhs.lower.
    //   */
    //  template <typename L, typename R>
    //  bool operator()(L const& lhs, R const& rhs) const
    //  {
    //      return lhs.upper < rhs.lower;
    //  }
    // };
 
    struct Comparator {
        using range_type     = std::pair<T, T>;
        using is_transparent = std::true_type;
 
        [[nodiscard]] constexpr bool operator()(Range lhs, Range rhs) const noexcept
        {
            // return lhs.upper < rhs.lower;
            return lhs.lower < rhs.lower && lhs.upper < rhs.upper;
        }
        [[nodiscard]] constexpr bool operator()(Range lhs, range_type rhs) const noexcept
        {
            // return lhs.upper < rhs.first;
            return lhs.lower < rhs.first && lhs.upper < rhs.second;
        }
        [[nodiscard]] constexpr bool operator()(range_type lhs, Range rhs) const noexcept
        {
            // return lhs.second < rhs.lower;
            return lhs.first < rhs.lower && lhs.second < rhs.upper;
        }
    };
 
    [[nodiscard]] constexpr bool contains(value_type value) const noexcept
    {
        return lower <= value && value <= upper;
    }
 
    [[nodiscard]] constexpr bool contains(Range const& other) const noexcept
    {
        return lower <= other.lower && other.upper <= upper;
    }
 
    [[nodiscard]] constexpr bool overlaps(Range const& other) const noexcept
    {
        return lower <= other.upper && other.lower <= upper;
    }
 
    [[nodiscard]] friend constexpr bool operator==(Range const& lhs,
                                                   Range const& rhs) noexcept = default;
 
    [[nodiscard]] friend constexpr bool operator<(Range const& lhs,
                                                  Range const& rhs) noexcept
    {
        return lhs.upper < rhs.lower;
    }
 
    [[nodiscard]] friend constexpr bool operator<=(Range const& lhs,
                                                   Range const& rhs) noexcept
    {
        return lhs.upper <= rhs.lower;
    }
 
    [[nodiscard]] friend constexpr bool operator>(Range const& lhs,
                                                  Range const& rhs) noexcept
    {
        return lhs.lower > rhs.upper;
    }
 
    [[nodiscard]] friend constexpr bool operator>=(Range const& lhs,
                                                   Range const& rhs) noexcept
    {
        return lhs.lower >= rhs.upper;
    }
 
    [[nodiscard]] friend constexpr bool operator==(Range const& lhs,
                                                   value_type   rhs) noexcept
    {
        return lhs.lower == rhs && lhs.upper == rhs;
    }
 
    [[nodiscard]] friend constexpr bool operator<(Range const& lhs, value_type rhs) noexcept
    {
        return lhs.upper < rhs;
    }
 
    [[nodiscard]] friend constexpr bool operator<=(Range const& lhs,
                                                   value_type   rhs) noexcept
    {
        return lhs.upper <= rhs;
    }
 
    [[nodiscard]] friend constexpr bool operator>(Range const& lhs, value_type rhs) noexcept
    {
        return lhs.lower > rhs;
    }
 
    [[nodiscard]] friend constexpr bool operator>=(Range const& lhs,
                                                   value_type   rhs) noexcept
    {
        return lhs.lower >= rhs;
    }
 
    [[nodiscard]] friend constexpr bool operator==(value_type   lhs,
                                                   Range const& rhs) noexcept
    {
        return rhs == lhs;
    }
 
    [[nodiscard]] friend constexpr bool operator<(value_type lhs, Range const& rhs) noexcept
    {
        return rhs > lhs;
    }
 
    [[nodiscard]] friend constexpr bool operator<=(value_type   lhs,
                                                   Range const& rhs) noexcept
    {
        return rhs >= lhs;
    }
 
    [[nodiscard]] friend constexpr bool operator>(value_type lhs, Range const& rhs) noexcept
    {
        return rhs < lhs;
    }
 
    [[nodiscard]] friend constexpr bool operator>=(value_type   lhs,
                                                   Range const& rhs) noexcept
    {
        return rhs <= lhs;
    }
};
 
}  // namespace ufo
 
template <class T>
struct std::formatter<ufo::Range<T>> {
    constexpr auto parse(std::format_parse_context& ctx) const { return ctx.begin(); }
 
    auto format(ufo::Range<T> const& r, std::format_context& ctx) const
    {
        if (r.lower == r.upper) {
            return std::format_to(ctx.out(), "[{}]", +r.lower);
        } else if constexpr (std::is_floating_point_v<T>) {
            return std::format_to(ctx.out(), "[{},{}]", +r.lower, +r.upper);
        } else {
            return std::format_to(ctx.out(), "[{}..{}]", +r.lower, +r.upper);
        }
    }
};
 
namespace ufo
{
template <class T>
std::ostream& operator<<(std::ostream& out, Range<T> const& r)
{
    return out << std::format("{}", r);
}
}  // namespace ufo
 
#endif  // UFO_CORE_RANGE_HPP