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 <optional>
#include <ostream>
 
namespace ap::nargs {
 
class range {
public:
    using count_type = std::size_t;
 
    range() : _lower_bound(_default_bound), _upper_bound(_default_bound) {}
 
    explicit range(const count_type n) : _lower_bound(n), _upper_bound(n) {}
 
    range(const count_type lower_bound, const count_type upper_bound)
    : _lower_bound(lower_bound), _upper_bound(upper_bound) {}
 
    range(const range&) = default;
    range(range&&) = default;
 
    range& operator=(const range&) = default;
    range& operator=(range&&) = default;
 
    ~range() = default;
 
    [[nodiscard]] bool is_bound() const noexcept {
        return this->_lower_bound.has_value() or this->_upper_bound.has_value();
    }
 
    [[nodiscard]] std::weak_ordering ordering(const range::count_type n) const noexcept {
        if (not (this->_lower_bound.has_value() or this->_upper_bound.has_value()))
            return std::weak_ordering::equivalent;
 
        if (this->_lower_bound.has_value() and this->_upper_bound.has_value()) {
            if (n < this->_lower_bound.value())
                return std::weak_ordering::less;
 
            if (n > this->_upper_bound.value())
                return std::weak_ordering::greater;
 
            return std::weak_ordering::equivalent;
        }
 
        if (this->_lower_bound.has_value())
            return (n < this->_lower_bound.value())
                     ? std::weak_ordering::less
                     : std::weak_ordering::equivalent;
 
        return (n > this->_upper_bound.value())
                 ? std::weak_ordering::greater
                 : std::weak_ordering::equivalent;
    }
 
    friend std::ostream& operator<<(std::ostream& os, const range& r) noexcept {
        if (r._lower_bound.has_value() and r._lower_bound == r._upper_bound) {
            os << r._lower_bound.value();
            return os;
        }
 
        if (not r._lower_bound.has_value() and not r._upper_bound.has_value()) {
            os << "unbound";
            return os;
        }
 
        os << "[" << r._lower_bound.value_or(0ull) << ", ";
        if (r._upper_bound.has_value())
            os << r._upper_bound.value() << "]";
        else
            os << "inf)";
 
        return os;
    }
 
    friend range at_least(const count_type) noexcept;
    friend range more_than(const count_type) noexcept;
    friend range less_than(const count_type) noexcept;
    friend range up_to(const count_type) noexcept;
    friend range any() noexcept;
 
private:
    range(const std::optional<count_type> lower_bound, const std::optional<count_type> upper_bound)
    : _lower_bound(lower_bound), _upper_bound(upper_bound) {}
 
    std::optional<count_type> _lower_bound;
    std::optional<count_type> _upper_bound;
 
    static constexpr count_type _default_bound = 1ull;
};
 
[[nodiscard]] inline range at_least(const range::count_type n) noexcept {
    return range(n, std::nullopt);
}
 
[[nodiscard]] inline range more_than(const range::count_type n) noexcept {
    return range(n + 1, std::nullopt);
}
 
[[nodiscard]] inline range less_than(const range::count_type n) noexcept {
    return range(std::nullopt, n - 1);
}
 
[[nodiscard]] inline range up_to(const range::count_type n) noexcept {
    return range(std::nullopt, n);
}
 
[[nodiscard]] inline range any() noexcept {
    return range(std::nullopt, std::nullopt);
}
 
} // namespace ap::nargs