Slice.hpp

Go to the documentation of this file.

 
#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 size_type distance = static_cast<size_type>(stop_) - static_cast<size_type>(start_);
            const size_type stride = static_cast<size_type>(step_);
            return 1 + (distance - 1) / stride;
        }
 
        if (start_ <= stop_)
        {
            return 0;
        }
 
        const size_type stride = size_type{0} - static_cast<size_type>(step_);
        const size_type distance = static_cast<size_type>(start_) - static_cast<size_type>(stop_);
        return 1 + (distance - 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_;}
};
 
}