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 SC
 
 
template <typename Type>
struct SC::Span
{
    using SizeType = size_t;
    using VoidType = typename TypeTraits::SameConstnessAs<Type, void>::type;
 
    template <size_t N>
    constexpr Span(Type (&_items)[N]) : items(_items), sizeElements(N)
    {}
 
    constexpr Span() : items(nullptr), sizeElements(0) {}
 
    constexpr Span(Type* items, SizeType sizeInElements) : items(items), sizeElements(sizeInElements) {}
 
    constexpr Span(Type& type) : items(&type), sizeElements(1) {}
 
    constexpr Span(std::initializer_list<Type> list) : items(nullptr), sizeElements(0)
    {
        // We need this two step initialization to avoid warnings on all compilers
        items        = list.begin();
        sizeElements = list.size();
    }
 
    operator Span<const Type>() const { return {items, sizeElements}; }
 
    template <typename T>
    [[nodiscard]] static Span<Type> reinterpret_object(T& value)
    {
        return {reinterpret_cast<Type*>(&value), sizeof(T) / sizeof(Type)};
    }
 
    [[nodiscard]] static Span<Type> reinterpret_bytes(VoidType* rawMemory, SizeType sizeInBytes)
    {
        return Span(reinterpret_cast<Type*>(rawMemory), sizeInBytes / sizeof(Type));
    }
 
    template <typename T>
    [[nodiscard]] Span<const T> reinterpret_as_array_of() const
    {
        return Span<const T>(reinterpret_cast<const T*>(items), sizeInBytes() / sizeof(T));
    }
 
    template <typename T>
    [[nodiscard]] Span<T> reinterpret_as_array_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 * sizeof(Type); }
 
    [[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]] const 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) / sizeof(Type));
            return true;
        }
    }
 
    [[nodiscard]] constexpr bool empty() const { return sizeElements == 0; }
 
    [[nodiscard]] constexpr bool contains(const Type& type, SizeType* index = nullptr) const
    {
        for (SizeType idx = 0; idx < sizeElements; ++idx)
        {
            if (items[idx] == type)
            {
                if (index)
                {
                    *index = idx;
                }
                return true;
            }
        }
        return false;
    }
 
    Type& operator[](SizeType idx) { return items[idx]; }
 
    const Type& operator[](SizeType idx) const { return items[idx]; }
 
    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;
    }
 
  private:
    Type*    items;
    SizeType sizeElements;
};
 
#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;
};