Span.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/InitializerList.h" // IWYU pragma: keep
#include "../Foundation/LibC.h"            // IWYU pragma: keep
#include "../Foundation/TypeTraits.h"      // SameConstnessAs
 
namespace SC
{
template <typename Type>
struct Span;
 
namespace detail
{
// clang-format off
template<typename U> struct SpanSizeOfType              { static constexpr auto size = sizeof(U);  };
template<>           struct SpanSizeOfType<void>        { static constexpr auto size = 1;          };
template<>           struct SpanSizeOfType<const void>  { static constexpr auto size = 1;          };
// clang-format on
} // namespace detail
 
 
template <typename Type>
struct Span
{
  private:
    // clang-format off
    using SizeType = size_t;
    using VoidType = typename TypeTraits::SameConstnessAs<Type, void>::type;
    template <typename U> using TypeIfNotVoid = typename TypeTraits::EnableIf<not TypeTraits::IsSame<U, VoidType>::value, Type>::type;
    template <typename U> using SameType = TypeTraits::IsSame<typename TypeTraits::RemoveConst<U>::type, typename TypeTraits::RemoveConst<Type>::type>;
    template <typename U> using EnableNotVoid = typename TypeTraits::EnableIf<SameType<U>::value and not TypeTraits::IsSame<U, VoidType>::value, bool>::type;
    // clang-format on
    Type*    items;
    SizeType sizeElements;
 
  public:
    template <size_t N, typename U = Type, EnableNotVoid<U> = true>
    constexpr Span(U (&itemsArray)[N]) : items(itemsArray), sizeElements(N)
    {}
 
    constexpr Span() : items(nullptr), sizeElements(0) {}
 
    constexpr Span(Type* items, SizeType sizeInElements) : items(items), sizeElements(sizeInElements) {}
 
    template <typename U = Type>
    constexpr Span(TypeIfNotVoid<U>& type) : items(&type), sizeElements(1)
    {}
 
    template <typename U = Type>
    constexpr Span(std::initializer_list<TypeIfNotVoid<U>> list) : items(nullptr), sizeElements(0)
    {
        // We need this two step initialization to avoid warnings on all compilers
        items        = list.begin();
        sizeElements = list.size();
    }
 
    // clang-format off
    template <typename U = Type> operator Span<const TypeIfNotVoid<U>>() const { return {items, sizeElements}; }
    template <typename U = Type> operator Span<      TypeIfNotVoid<U>>()       { return {items, sizeElements}; }
    operator Span<const void>() const { return Span<const void>(items, sizeElements * detail::SpanSizeOfType<Type>::size); }
    operator Span<void>() { return Span<void>(items, sizeElements * detail::SpanSizeOfType<Type>::size); }
 
    template <typename T> [[nodiscard]] static Span<Type> reinterpret_object(T& value) { return {reinterpret_cast<Type*>(&value), sizeof(T) / detail::SpanSizeOfType<Type>::size}; }
 
    [[nodiscard]] static Span<Type> reinterpret_bytes(VoidType* rawMemory, SizeType sizeInBytes) { return Span(reinterpret_cast<Type*>(rawMemory), sizeInBytes / detail::SpanSizeOfType<Type>::size); }
 
    template <typename T> [[nodiscard]] Span<const T> reinterpret_as_span_of() const { return Span<const T>(reinterpret_cast<const T*>(items), sizeInBytes() / sizeof(T)); }
 
    template <typename T> [[nodiscard]] Span<T> reinterpret_as_span_of() { return Span<T>(reinterpret_cast<T*>(items), sizeInBytes() / sizeof(T)); }
 
    [[nodiscard]] constexpr const Type* begin() const { return items; }
    [[nodiscard]] constexpr const Type* end() const { return items + sizeElements; }
    [[nodiscard]] constexpr const Type* data() const { return items; }
    [[nodiscard]] constexpr Type* begin() { return items; }
    [[nodiscard]] constexpr Type* end() { return items + sizeElements; }
    [[nodiscard]] constexpr Type* data() { return items; }
 
    [[nodiscard]] constexpr SizeType sizeInElements() const { return sizeElements; }
    [[nodiscard]] constexpr SizeType sizeInBytes() const { return sizeElements * detail::SpanSizeOfType<Type>::size; }
 
    [[nodiscard]] constexpr bool empty() const { return sizeElements == 0; }
 
    template <typename U = Type> TypeIfNotVoid<U>& operator[](SizeType idx) {  return items[idx]; }
    template <typename U = Type> const TypeIfNotVoid<U>& operator[](SizeType idx) const { return items[idx]; }
    // clang-format on
 
    [[nodiscard]] constexpr bool sliceStart(SizeType offsetInElements, Span& destination) const
    {
        bool valid  = offsetInElements <= sizeElements;
        destination = valid ? Span(items + offsetInElements, sizeElements - offsetInElements) : Span(nullptr, 0);
        return valid;
    }
 
    [[nodiscard]] constexpr bool sliceStartLength(SizeType offsetInElements, SizeType lengthInElements,
                                                  Span& destination) const
    {
        bool valid  = offsetInElements + lengthInElements <= sizeElements;
        destination = valid ? Span(items + offsetInElements, lengthInElements) : Span(nullptr, 0);
        return valid;
    }
};
 
} // namespace SC