span.h

 
#pragma once
 
#include <algorithm>
#include <type_traits>
 
#include <system/array.h>
#include <system/details/stack_array.h>
#include <system/collections/ienumerator.h>
#include <system/convert.h>
#include <system/smart_ptr.h>
#include <system/string.h>
#include <system/exceptions.h>
#include <system/make_const_ref.h>
 
namespace System {
 
namespace Details {
 
template <typename T, typename Span, typename MutableSpan>
class SpanCore
{
protected:
    using MutableT = std::remove_const_t<T>;
    using RefrerenceT = std::conditional_t<std::is_const<T>::value, MakeConstRef_t<MutableT>, T&>;
    using ArrayPtrT = System::ArrayPtr<MutableT>;
    using VoidPtrT = std::conditional_t<std::is_const<std::remove_pointer_t<T>>::value, const void*, void*>;
 
public:
    class Enumerator
    {
        friend SpanCore;
 
        SpanCore m_span;
        int32_t m_idx = -1;
 
        explicit Enumerator(const SpanCore& span) : m_span(span)
        {}
 
    public:
        RefrerenceT get_Current()
        {
            if (m_idx < 0 || m_idx >= m_span.get_Length())
            {
                throw IndexOutOfRangeException(u"index");
            }
 
            return  m_span.get(m_idx);
        }
 
        bool MoveNext()
        {
            if (m_idx < m_span.get_Length())
            {
                m_idx++;
            }
 
            return m_idx < m_span.get_Length();
        }
 
        void Reset()
        {
            m_idx = -1;
        }
    };
 
public:
    SpanCore() : SpanCore(nullptr, nullptr, 0)
    {}
 
    SpanCore(const ArrayPtrT& array) : SpanCore(array, array == nullptr ? nullptr : array->data_ptr(), array == nullptr ? 0 : array->get_Length())
    {}
 
    template <std::size_t Size>
    SpanCore(Details::StackArray<MutableT, Size>& stack_array) : SpanCore(stack_array.data(), Size)
    {}
 
    SpanCore(VoidPtrT pointer, int32_t length) : SpanCore(nullptr, (T*)pointer, length)
    {
        if (length < 0)
        {
            throw ArgumentOutOfRangeException(u"length");
        }
    }
 
    SpanCore(const ArrayPtrT& array, int32_t start, int32_t length) : SpanCore(array, array->data_ptr() + start, length)
    {
        if (array == nullptr)
        {
            if (start != 0)
            {
                throw ArgumentOutOfRangeException(u"start");
            }
            if (length != 0)
            {
                throw ArgumentOutOfRangeException(u"length");
            }
        }
        else
        {
            if (start < 0 || (start > 0 && start >= array->get_Length()))
            {
                throw ArgumentOutOfRangeException(u"start");
            }
            if (start + length > array->get_Length())
            {
                throw ArgumentOutOfRangeException(u"length");
            }
        }
    }
 
    static Span get_Empty()
    {
        return Span(nullptr, nullptr, 0);
    }
 
    Enumerator GetEnumerator() const
    {
        return Enumerator(*this);
    }
 
    int32_t GetHashCode() const
    {
        throw NotSupportedException();
    }
 
    bool get_IsEmpty() const
    {
        return m_length == 0;
    }
 
    int32_t get_Length() const
    {
        return m_length;
    }
 
    Span Slice(int32_t start) const
    {
        return Slice(start, m_length - start);
    }
 
    Span Slice(int32_t start, int32_t length) const
    {
        if (start < 0)
        {
            throw ArgumentOutOfRangeException(u"start");
        }
        else if (length < 0 || start + length > m_length)
        {
            throw ArgumentOutOfRangeException(u"length");
        }
 
        return Span(m_array, m_pointer + start, length);
    }
 
    void CopyTo(MutableSpan destination) const
    {
        if (m_length > destination.get_Length())
        {
            throw ArgumentException(u"destination");
        }
 
        std::copy(cbegin(), cend(), destination.begin());
    }
 
    bool TryCopyTo(MutableSpan destination) const
    {
        if (m_length > destination.get_Length())
        {
            return false;
        }
 
        std::copy(cbegin(), cend(), destination.begin());
 
        return true;
    }
 
    ArrayPtrT ToArray() const
    {
        auto result = System::MakeArray<MutableT>(m_length);
 
        std::copy(cbegin(), cend(), result->begin());
 
        return result;
    }
 
    template <typename T1 = MutableT>
    typename std::enable_if<std::is_same<T1, char16_t>::value, String>::type ToString() const
    {
        return System::String(ToArray());
    }
 
    template <typename T1 = MutableT>
    typename std::enable_if<!std::is_same<T1, char16_t>::value, String>::type ToString() const
    {
        return u"System::Span<T>[" + System::Convert::ToString(m_length) + u"]";
    }
 
public:
    // Iterator support
    T* begin() const noexcept
    {
        return m_pointer;
    }
 
    T* end() const noexcept
    {
        return m_pointer + m_length;
    }
 
    const T* cbegin() const noexcept
    {
        return m_pointer;
    }
 
    const T* cend() const noexcept
    {
        return m_pointer + m_length;
    }
 
    T* rbegin() const noexcept
    {
        return m_pointer + m_length;
    }
 
    T* rend() const noexcept
    {
        return m_pointer;
    }
 
    const T* crbegin() const noexcept
    {
        return m_pointer + m_length;
    }
 
    const T* crend() const noexcept
    {
        return m_pointer;
    }
 
    RefrerenceT operator[](int32_t index) const
    {
        if (index < 0 || index >= m_length)
        {
            throw IndexOutOfRangeException(u"index");
        }
 
        return *(m_pointer + index);
    }
 
    RefrerenceT get(int32_t index) const
    {
        return *(m_pointer + index);
    }
 
    bool operator==(const SpanCore& right) const
    {
        return m_pointer == right.m_pointer && m_length == right.m_length;
    }
 
    template <std::size_t Size>
    SpanCore& operator = (Details::StackArray<MutableT, Size>& stack_array) 
    {
        m_pointer = stack_array.data();
        m_length = Size;
        m_array = nullptr;
 
        return *this;
    }
 
protected:
    SpanCore(const ArrayPtrT& array, T* pointer, int32_t length)
        : m_array(array), m_pointer(pointer), m_length(length)
    {}
 
    T*        m_pointer; 
    int32_t   m_length;  
    ArrayPtrT m_array;   
};
 
} // namespace Details
 
template <typename T>
class ReadOnlySpan;
 
template <typename T>
class Span : public Details::SpanCore<T, Span<T>, Span<T>>
{
    typedef Span<T> ThisType;
    typedef typename Details::SpanCore<T, Span<T>, Span<T>> BaseType;
 
    friend BaseType;
    friend ReadOnlySpan<T>;
 
public:
    using Details::SpanCore<T, Span<T>, Span<T>>::SpanCore;
    using Details::SpanCore<T, Span<T>, Span<T>>::operator=;
 
    void Clear() const
    {
        std::fill(this->begin(), this->end(), System::Default<T>());
    }
 
    void Fill(const T& value) const
    {
        std::fill(this->begin(), this->end(), value);
    }
 
    static ThisType to_Span(const typename BaseType::ArrayPtrT& array)
    {
        return ThisType(array);
    }
};
 
template <typename T>
class ReadOnlySpan : public Details::SpanCore<const T, ReadOnlySpan<T>, Span<T>>
{
    typedef ReadOnlySpan<T> ThisType;
    typedef typename Details::SpanCore<const T, ReadOnlySpan<T>, Span<T>> BaseType;
 
    friend BaseType;
 
public:
    using Details::SpanCore<const T, ReadOnlySpan<T>, Span<T>>::SpanCore;
    using Details::SpanCore<const T, ReadOnlySpan<T>, Span<T>>::operator=;
 
    ReadOnlySpan(const Span<T>& span) : BaseType(span.m_array, span.m_pointer, span.m_length)
    {}
 
    static ThisType to_ReadOnlySpan(const typename BaseType::ArrayPtrT& array)
    {
        return ThisType(array);
    }
};
 
} // namespace System