range.hpp

Go to the documentation of this file.

// Copyright (c) 2023-2025 Jakub Musiał
// This file is part of the CPP-AP project (https://github.com/SpectraL519/cpp-ap).
// Licensed under the MIT License. See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <format>
#include <limits>
#include <ostream>
 
namespace ap::nargs {
 
using count_type = std::size_t;
 
constexpr count_type min_bound = std::numeric_limits<count_type>::min();
 
constexpr count_type max_bound = std::numeric_limits<count_type>::max();
 
class range {
public:
    constexpr range() = default;
 
    explicit constexpr range(const count_type n) : _lower_bound(n), _upper_bound(n) {}
 
    constexpr range(const count_type lower, const count_type upper)
    : _lower_bound(lower), _upper_bound(upper) {
        if (upper < lower)
            throw std::logic_error(
                std::format("Invalid range bounds: lower = {}, upper = {}", lower, upper)
            );
    }
 
    [[nodiscard]] constexpr bool has_explicit_lower_bound() const noexcept {
        return this->_lower_bound > min_bound;
    }
 
    [[nodiscard]] constexpr bool has_explicit_upper_bound() const noexcept {
        return this->_upper_bound < max_bound;
    }
 
    [[nodiscard]] constexpr bool is_explicitly_bound() const noexcept {
        return this->has_explicit_lower_bound() or this->has_explicit_upper_bound();
    }
 
    [[nodiscard]] constexpr bool is_exactly_bound() const noexcept {
        return this->_lower_bound == this->_upper_bound;
    }
 
    constexpr bool operator==(const range& other) const = default;
 
    [[nodiscard]] friend constexpr std::weak_ordering operator<=>(
        const count_type n, const range& r
    ) noexcept {
        if (n < r._lower_bound)
            return std::weak_ordering::less;
 
        if (n > r._upper_bound)
            return std::weak_ordering::greater;
 
        return std::weak_ordering::equivalent;
    }
 
    friend std::ostream& operator<<(std::ostream& os, const range& r) noexcept {
        if (not r.is_explicitly_bound()) {
            os << "unbound";
            return os;
        }
 
        if (r.is_exactly_bound()) {
            os << r._upper_bound;
            return os;
        }
 
        os << "[" << r._lower_bound << ", ";
        if (r.has_explicit_upper_bound())
            os << r._upper_bound << "]";
        else
            os << "inf)";
 
        return os;
    }
 
    friend constexpr range at_least(const count_type) noexcept;
    friend constexpr range more_than(const count_type) noexcept;
    friend constexpr range less_than(const count_type) noexcept;
    friend constexpr range up_to(const count_type) noexcept;
    friend constexpr range any() noexcept;
 
private:
    count_type _lower_bound = min_bound;
    count_type _upper_bound = max_bound;
};
 
[[nodiscard]] constexpr range at_least(const count_type n) noexcept {
    return range(n, max_bound);
}
 
[[nodiscard]] constexpr range more_than(const count_type n) noexcept {
    return range(n + 1ull, max_bound);
}
 
[[nodiscard]] constexpr range less_than(const count_type n) noexcept {
    return range(min_bound, n - 1ull);
}
 
[[nodiscard]] constexpr range up_to(const count_type n) noexcept {
    return range(min_bound, n);
}
 
[[nodiscard]] constexpr range any() noexcept {
    return range(min_bound, max_bound);
}
 
} // namespace ap::nargs