ReflectionFoundation.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/Compiler.h"
#include "../Foundation/Span.h"
namespace SC
{
namespace Reflection
{
 
template <typename T, uint32_t N>
struct ArrayWithSize
{
    T        values[N] = {};
    uint32_t size      = 0;
 
    operator Span<const T>() const { return {values, size}; }
    [[nodiscard]] constexpr bool contains(T value, uint32_t* outIndex = nullptr) const
    {
        for (uint32_t i = 0; i < size; ++i)
        {
            if (values[i] == value)
            {
                if (outIndex)
                    *outIndex = i;
                return true;
            }
        }
        return false;
    }
 
    template <uint32_t N2>
    [[nodiscard]] constexpr bool append(const ArrayWithSize<T, N2>& other)
    {
        if (size + other.size >= N)
            return false;
        for (uint32_t i = 0; i < other.size; ++i)
        {
            values[size++] = other.values[i];
        }
        return true;
    }
 
    [[nodiscard]] constexpr bool push_back(const T& value)
    {
        if (size < N)
        {
            values[size++] = value;
            return true;
        }
        return false;
    }
 
    bool equals(Span<const T> other) const
    {
        return size == other.sizeInElements() and ::memcmp(values, other.data(), other.sizeInBytes()) == 0;
    }
};
 
template <typename Type>
struct WritableRange
{
    Type* iterator;
    Type* iteratorEnd;
 
    constexpr WritableRange(Type* iteratorStart, const uint32_t capacity)
        : iterator(iteratorStart), iteratorEnd(iteratorStart + capacity)
    {}
 
    [[nodiscard]] constexpr bool writeAndAdvance(const Type& value)
    {
        if (iterator < iteratorEnd)
        {
            *iterator = value;
            iterator++;
            return true;
        }
        return false;
    }
};
 
struct Sv
{
    const char* data;   
    uint32_t    length; 
 
    constexpr Sv() : data(nullptr), length(0) {}
 
    constexpr Sv(const char* data, uint32_t length) : data(data), length(length) {}
 
    template <uint32_t N>
    constexpr Sv(const char (&data)[N]) : data(data), length(N - 1)
    {}
 
    constexpr bool operator==(const Sv other) const
    {
        if (length != other.length)
            return false;
        for (uint32_t idx = 0; idx < length; ++idx)
        {
            if (data[idx] != other.data[idx])
                return false;
        }
        return true;
    }
};
 
template <typename T>
static constexpr Sv ClNm()
{
    // clang-format off
#if SC_COMPILER_CLANG || SC_COMPILER_GCC
    const char* name = __PRETTY_FUNCTION__;
    constexpr char separating_char = '=';
    constexpr uint32_t  skip_chars = 2;
    constexpr uint32_t  trim_chars = 1;
    uint32_t         length = 0;
    const char* it = name;
    while (*it != separating_char)
        it++;
    it += skip_chars;
    while (it[length] != 0)
        length++;
    return Sv(it, length - trim_chars);
#else
    const char* name = __FUNCSIG__;
    constexpr char separating_char = '<';
    constexpr char ending_char = '>';
    const char* it = name;
    while (*it != separating_char)
        it++;
    auto itStart = it + 1;
    while (*it != ending_char)
    {
        if (*it == ' ')
            itStart = it + 1;
        it++;
    }
    return Sv(itStart, static_cast<int>(it - itStart));
#endif
    // clang-format on
}
 
using TypeStringView = Sv;
 
template <typename T>
struct TypeToString
{
#if SC_LANGUAGE_CPP_AT_LEAST_17
  private:
    // In C++ 17 we trim the long string producted by ClassName<T> to reduce executable size
    [[nodiscard]] static constexpr auto TrimClassName()
    {
        constexpr auto className = ClNm<T>();
 
        ArrayWithSize<char, className.length> trimmedName;
        for (uint32_t i = 0; i < className.length; ++i)
        {
            trimmedName.values[i] = className.data[i];
        }
        trimmedName.size = className.length;
        return trimmedName;
    }
 
    // Inline static constexpr requires C++17
    static inline constexpr auto value = TrimClassName();
 
  public:
    [[nodiscard]] static constexpr TypeStringView get() { return TypeStringView(value.values, value.size); }
#else
    [[nodiscard]] static constexpr TypeStringView get()
    {
        auto className = ClNm<T>();
        return TypeStringView(className.data, className.length);
    }
#endif
};
 
 
} // namespace Reflection
} // namespace SC