interval.hpp

/*
    SPDX-License-Identifier: MIT
    Copyright © 2023-2024 Amebis
*/
 
#pragma once
 
#include "compat.hpp"
#include <vector>
 
namespace stdex
{
    template <class T>
    struct interval
    {
        T start; 
        T end;   
 
        interval() noexcept : start(static_cast<T>(1)), end(static_cast<T>(0)) {}
 
        interval(_In_ T x) noexcept : start(x), end(x) {}
 
        interval(_In_ T _start, _In_ T _end) noexcept : start(_start), end(_end) {}
 
        T size() const { return start <= end ? end - start : 0; }
 
        bool empty() const { return start >= end; }
 
        void invalidate()
        {
            start = static_cast<T>(1);
            end = static_cast<T>(0);
        }
 
        operator bool() const { return start <= end; }
 
        bool contains(_In_ T x) const { return start <= x && x < end; }
 
        interval<T> operator+(_In_ const interval<T>& other) const
        {
            return interval<T>(start + other.start, end + other.end);
        }
 
        interval<T> operator+(_In_ const T x) const
        {
            return interval<T>(start + x, end + x);
        }
 
        interval<T> operator++()
        {
            ++start;
            ++end;
            return *this;
        }
 
        interval<T> operator++(int) // Postfix increment operator.
        {
            interval<T> r = *this;
            ++start;
            ++end;
            return r;
        }
 
        interval<T> operator-(_In_ const interval<T>& other) const
        {
            return interval<T>(start - other.start, end - other.end);
        }
 
        interval<T> operator-(_In_ const T x) const
        {
            return interval<T>(start - x, end - x);
        }
 
        interval<T> operator--()
        {
            --start;
            --end;
            return *this;
        }
 
        interval<T> operator--(int) // Postfix decrement operator.
        {
            interval<T> r = *this;
            --start;
            --end;
            return r;
        }
 
        bool operator==(_In_ const interval<T>& other) const
        {
            return start == other.start && end == other.end;
        }
 
        bool operator!=(_In_ const interval<T>& other) const
        {
            return !operator ==(other);
        }
    };
 
    template <class T, class AX = std::allocator<interval<T>>>
    using interval_vector = std::vector<interval<T>, AX>;
}