range.h

 
#pragma once
 
#include <system/index.h>
#include <system/exceptions.h>
#include <system/value_tuple.h>
 
namespace System {
 
class Range : public ::System::Details::BoxableObjectBase
{
    RTTI_INFO_VALUE_TYPE(Range)
 
public:
    constexpr Range() noexcept : m_start(), m_end() {}
 
    constexpr Range(const Index& start, const Index& end) noexcept : m_start(start), m_end(end) {}
 
    static constexpr Range get_All() noexcept
    {
        return Range(Index::get_Start(), Index::get_End());
    }
 
    static constexpr Range StartAt(const Index& start) noexcept
    {
        return Range(start, Index::get_End());
    }
 
    static constexpr Range EndAt(const Index& end) noexcept
    {
        return Range(Index::get_Start(), end);
    }
 
    const Index& get_Start() const noexcept
    {
        return m_start;
    }
 
    const Index& get_End() const noexcept
    {
        return m_end;
    }
 
    System::ValueTuple<int32_t, int32_t> GetOffsetAndLength(int32_t length) const
    {
        int32_t start = m_start.GetOffset(length);
        int32_t end = m_end.GetOffset(length);
 
        if ((uint32_t)end > (uint32_t)length || (uint32_t)start > (uint32_t)end)
        {
            throw ArgumentOutOfRangeException();
        }
 
        return {start, end - start};
    }
 
    bool Equals(const Range& other) const
    {
        return m_start.Equals(other.m_start) && m_end.Equals(other.m_end);
    }
 
    int32_t GetHashCode() const
    {
        return m_start.GetHashCode() ^ (m_end.GetHashCode() << 2);
    }
 
private:
    Index m_start;
    Index m_end;
};
 
template <typename T>
auto Get(T& collection, const Range& range)
{
    auto& ref = Details::Dereference(collection);
    auto size = Details::GetCollectionSize(ref);
    auto offsetAndLength = range.GetOffsetAndLength(size);
    return Details::GetCollectionSlice(ref, offsetAndLength.template Item<0>(), offsetAndLength.template Item<1>());
}
 
} // namespace System