Span.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/InitializerList.h"
#include "../Foundation/LibC.h"       // memcmp
#include "../Foundation/TypeTraits.h" // SameConstnessAs
 
namespace SC
{
template <typename Type>
struct Span;
 
struct SpanStringView;
struct SpanString;
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
} // namespace SC
 
 
template <typename Type>
struct SC::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)); }
 
    template <typename T> [[nodiscard]] T* start_lifetime_as_array() const noexcept
    {
        // TODO: Not a fully compliant implementation, replace it with a proper one under C++23
        // https://stackoverflow.com/questions/79164176/emulate-stdstart-lifetime-as-array-in-c20
        void* p = const_cast<void*>(static_cast<const void*>(data()));
        return sizeElements == 0 ? static_cast<const T*>(p) : launder(static_cast<const T*>(::memmove(p, p, sizeof(T) * sizeElements)));
    }
 
    template <typename T> [[nodiscard]] T* start_lifetime_as_array() noexcept
    {
        void* p = data();
        return sizeElements == 0 ? static_cast<T*>(p) : launder(static_cast<T*>(::memmove(p, p, sizeof(T) * sizeElements)));
    }
 
    template <typename T> [[nodiscard]] const T* start_lifetime_as() const noexcept
    {
        void* p = const_cast<void*>(static_cast<const void*>(data()));
        return launder(static_cast<const T*>(::memmove(p, p, sizeof(T))));
    }
 
    template <typename T> [[nodiscard]] T* start_lifetime_as() noexcept
    {
        void* p = data();
        return launder(static_cast<T*>(::memmove(p, p, sizeof(T))));
    }
    // clang-format on
 
    [[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 sliceStart(SizeType offsetInElements, Span& destination) const
    {
        if (offsetInElements <= sizeInElements())
        {
            destination = Span(items + offsetInElements, (sizeInElements() - offsetInElements));
            return true;
        }
        return false;
    }
 
    [[nodiscard]] constexpr bool sliceStartLength(SizeType offsetInElements, SizeType lengthInElements,
                                                  Span& destination) const
    {
        if (offsetInElements + lengthInElements <= sizeInElements())
        {
            destination = Span(items + offsetInElements, lengthInElements);
            return true;
        }
        return false;
    }
 
    [[nodiscard]] bool sliceFromStartUntil(Span other, Span& output) const
    {
        const auto diff = other.items - items;
        if (diff < 0 or static_cast<SizeType>(diff) > sizeInBytes())
        {
            return false;
        }
        else
        {
            output = Span(items, static_cast<SizeType>(diff) / detail::SpanSizeOfType<Type>::size);
            return true;
        }
    }
 
    [[nodiscard]] constexpr bool empty() const { return sizeElements == 0; }
 
    template <typename U>
    [[nodiscard]] constexpr bool contains(const U& value, SizeType* index = nullptr) const
    {
        return find([&](auto& current) { return current == value; }, index);
    }
 
    template <typename Lambda>
    [[nodiscard]] constexpr bool find(Lambda&& lambda, SizeType* index = nullptr) const
    {
        for (SizeType idx = 0; idx < sizeElements; ++idx)
        {
            if (lambda(items[idx]))
            {
                if (index)
                {
                    *index = idx;
                }
                return true;
            }
        }
        return false;
    }
 
    // clang-format off
    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
 
    template <typename IntType>
    Type* get(IntType idx)
    {
        if (idx >= 0 and idx < static_cast<IntType>(sizeElements))
            return items + idx;
        return nullptr;
    }
 
    template <typename IntType>
    const Type* get(IntType idx) const
    {
        if (idx >= 0 and idx < static_cast<IntType>(sizeElements))
            return items + idx;
        return nullptr;
    }
 
    template <typename U>
    [[nodiscard]] bool memcmpWith(const Span<U> other) const
    {
        if (sizeInBytes() != other.sizeInBytes())
            return false;
        if (sizeInBytes() == 0)
            return true;
        return ::memcmp(items, other.data(), sizeInBytes()) == 0;
    }
 
    template <typename U>
    [[nodiscard]] bool memcpyTo(Span<U>& other) const
    {
        if (other.sizeInBytes() < sizeInBytes())
            return false;
        ::memcpy(other.data(), items, sizeInBytes());
        other = {other.data(), sizeInBytes() / sizeof(U)};
        return true;
    }
};
 
#if SC_PLATFORM_WINDOWS
#define SC_NATIVE_STR(str) L##str
#else
#define SC_NATIVE_STR(str) str
#endif
 
struct SC::SpanStringView
{
    constexpr SpanStringView() = default;
    constexpr SpanStringView(const char* string, size_t stringLength) : text(string, stringLength) {}
    template <size_t N>
    constexpr SpanStringView(const char (&charLiteral)[N]) : text(charLiteral)
    {}
 
    template <int N>
    [[nodiscard]] bool writeNullTerminated(char (&buffer)[N]) const
    {
        if (N < text.sizeInElements() + 1)
            return false;
        ::memcpy(&buffer[0], text.data(), text.sizeInElements());
        buffer[N - 1] = 0;
        return true;
    }
 
    Span<const char> text;
};
 
struct SC::SpanString
{
    template <size_t N>
    constexpr SpanString(char (&buffer)[N]) : text(buffer)
    {}
 
    operator SpanStringView() const
    {
        SpanStringView sv;
        sv.text = text;
        return sv;
    }
 
    SC::Span<char> text;
};