Span.hpp

#pragma once
 
#include <type_traits>
 
#include <Common/Assert.hpp>
#include <Common/IntTypes.hpp>
 
#include "Iterators.hpp"
 
namespace Grindstone::Containers {
    template<typename T>
    class Span {
    public:
        using Iterator = ArrayIterator<T>;
        using ConstIterator = ConstArrayIterator<T>;
        using ReverseIterator = ReverseArrayIterator<T>;
        using ConstReverseIterator = ConstArrayIterator<T>;
 
        Span() = default;
 
        Span(T* ptr, size_t size) : size(size), contents(ptr) {}
        
        Span(const Span& other) : size(other.size), contents(other.contents) {}
 
        Span(Span&& other) noexcept : size(other.size), contents(other.contents) {
            other.size = 0;
            other.contents = nullptr;
        }
 
        template <typename U,
                  std::enable_if_t<std::is_convertible_v<U*, T*>, int> = 0>
        Span(const Span<U>& other)
            : size(other.GetSize()), contents(std::move(other.contents)) {}
 
        template <typename U,
                  std::enable_if_t<std::is_convertible_v<U*, T*>, int> = 0>
        Span(Span<U>&& other) noexcept
            : size(other.GetSize()), contents(std::move(other.contents)) {
            other.size = 0;
            other.contents = nullptr;
        }
 
        template <typename U,
                  std::enable_if_t<std::is_convertible_v<U*, T*>, int> = 0>
        Span& operator=(const Span<U>& other) {
            size = other.size;
            contents = other.contents;
 
            return *this;
        }
 
        template <typename U,
                  std::enable_if_t<std::is_convertible_v<U*, T*>, int> = 0>
        Span& operator=(Span<U>&& other) noexcept {
            if (this != reinterpret_cast<Span<T>*>(&other)) {
                size = other.size;
                contents = other.contents;
                other.size = 0;
                other.contents = nullptr;
            }
            return *this;
        }
 
        Span& operator=(const Span& other) {
            size = other.size;
            contents = other.contents;
        }
 
        Span& operator=(Span&& other) noexcept {
            size = other.size;
            contents = other.contents;
 
            other.size = 0;
            other.contents = nullptr;
 
            return *this;
        }
 
        ~Span() {
            contents = nullptr;
            size = 0;
        }
 
        [[nodiscard]] const T& GetBegin() const {
            return contents[0];
        }
 
        [[nodiscard]] T& GetBegin() {
            return contents[0];
        }
 
        [[nodiscard]] const T& GetEnd() const {
            return contents[size];
        }
 
        [[nodiscard]] T& GetEnd() {
            return contents[size];
        }
 
        bool TryGet(T& outValue, size_t index) {
            if (index < size) {
                outValue = contents[index];
                return true;
            }
 
            return false;
        }
 
        size_t GetSize() const {
            return size;
        }
 
        Span<T> GetSubspan(size_t firstIndex, size_t count) {
            GS_ASSERT_ENGINE_WITH_MESSAGE(count == 0 || firstIndex + count <= size, "Array index is invalid.");
            return Span<T>{ &contents[firstIndex], count };
        }
 
        T& operator[](size_t index) {
            GS_ASSERT_ENGINE_WITH_MESSAGE(index < size, "Array index is invalid.");
            return contents[index];
        }
 
        const T& operator[](size_t index) const {
            GS_ASSERT_ENGINE_WITH_MESSAGE(index < size, "Array index is invalid.");
            return contents[index];
        }
 
        [[nodiscard]] constexpr Iterator begin() noexcept {
            return Iterator(contents);
        }
 
        [[nodiscard]] constexpr ConstIterator begin() const noexcept {
            return ConstIterator(contents);
        }
 
        [[nodiscard]] constexpr Iterator end() noexcept {
            return Iterator(&contents[size]);
        }
 
        [[nodiscard]] constexpr ConstIterator end() const noexcept {
            return ConstIterator(&contents[size]);
        }
 
        [[nodiscard]] constexpr ReverseIterator rbegin() noexcept {
            return ReverseIterator(end());
        }
 
        [[nodiscard]] constexpr ConstReverseIterator rbegin() const noexcept {
            return ConstReverseIterator(end());
        }
 
        [[nodiscard]] constexpr ReverseIterator rend() noexcept {
            return ReverseIterator(begin());
        }
 
        [[nodiscard]] constexpr ConstReverseIterator rend() const noexcept {
            return ConstReverseIterator(begin());
        }
 
        [[nodiscard]] constexpr ConstIterator cbegin() const noexcept {
            return ConstIterator(contents);
        }
 
        [[nodiscard]] constexpr ConstIterator cend() const noexcept {
            return ConstIterator(&contents[size]);
        }
 
        [[nodiscard]] constexpr ConstReverseIterator crbegin() const noexcept {
            return ConstReverseIterator(end());
        }
 
        [[nodiscard]] constexpr ConstReverseIterator crend() const noexcept {
            return ConstReverseIterator(begin());
        }
    protected:
        size_t size = 0;
        T* contents = nullptr;
    };
 
    using BufferSpan = Span<Grindstone::Byte>;
 
    template<typename T>
    class ReverseRange {
    public:
        explicit ReverseRange(T& iterable) : iterable{ iterable } {}
        auto begin() const { return std::rbegin(iterable); }
        auto end() const { return std::rend(iterable); }
    private:
        T& iterable;
    };
 
    template<typename T>
    class ReverseRangeTemp {
    public:
        explicit ReverseRangeTemp(T&& iterable) : iterable{ std::move(iterable) } {}
        auto begin() const { return std::rbegin(iterable); }
        auto end() const { return std::rend(iterable); }
    private:
        T iterable;
    };
}