Slice.hpp

// TODO: make size() overflow-safe for extreme ptrdiff_t bounds and steps.
#pragma once
 
#include <cstddef>
 
#include <stratax/exceptions/Exceptions.hpp>
 
namespace stratax::core {
 
class Slice
{
public:
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
 
private:
    difference_type start_;
    difference_type stop_;
    difference_type step_;
 
public:
    Slice(difference_type start, difference_type stop, difference_type step = 1)
        : start_(start),
          stop_(stop),
          step_(step)
    {
        if (step == 0) {
            throw Exceptions::IndexError("Slice step cannot be zero.");
        }
    }
 
    [[nodiscard]] difference_type start() const noexcept {return start_;}
    [[nodiscard]] difference_type stop() const noexcept {return stop_;}
    [[nodiscard]] difference_type step() const noexcept {return step_;}
 
    [[nodiscard]] size_type size() const noexcept
    {
        if (step_ > 0)
        {
            if (start_ >= stop_)
            {
                return 0;
            }
 
            const difference_type distance = stop_ - start_;
            return static_cast<size_type>((distance + step_ - 1) / step_);
        }
 
        if (start_ <= stop_)
        {
            return 0;
        }
 
        const difference_type stride = -step_;
        const difference_type distance = start_ - stop_;
        return static_cast<size_type>((distance + stride - 1) / stride);
    }
 
    [[nodiscard]] bool empty() const noexcept {return size() == 0;}
 
    [[nodiscard]] bool operator==(const Slice& other) const noexcept {return start_ == other.start_ && stop_ == other.stop_ && step_ == other.step_;}
};
 
}