Reflection.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
 
#include "../Foundation/TypeTraits.h" // EnableIf
#include "ReflectionFoundation.h"
 
namespace SC
{
namespace Reflection
{
 
 
enum class TypeCategory : uint8_t
{
    TypeInvalid = 0, 
 
    // Primitive types
    TypeBOOL     = 1,  
    TypeUINT8    = 2,  
    TypeUINT16   = 3,  
    TypeUINT32   = 4,  
    TypeUINT64   = 5,  
    TypeINT8     = 6,  
    TypeINT16    = 7,  
    TypeINT32    = 8,  
    TypeINT64    = 9,  
    TypeFLOAT32  = 10, 
    TypeDOUBLE64 = 11, 
 
    // Non primitive types
    TypeStruct = 12, 
    TypeArray  = 13, 
    TypeVector = 14, 
};
 
struct TypeInfo
{
    bool         hasLink : 1; 
    TypeCategory type    : 7; 
    union
    {
        uint8_t numberOfChildren; 
        uint8_t linkIndex;        
    };
    uint16_t sizeInBytes; 
 
    struct EmptyInfo
    {
    };
 
    struct MemberInfo
    {
        uint16_t memberTag;     
        uint16_t offsetInBytes; 
        constexpr MemberInfo(uint8_t memberTag, uint16_t offsetInBytes)
            : memberTag(memberTag), offsetInBytes(offsetInBytes)
        {}
    };
 
    struct StructInfo
    {
        bool isPacked : 1; 
        constexpr StructInfo(bool isPacked) : isPacked(isPacked) {}
    };
 
    struct ArrayInfo
    {
        uint32_t isPacked    : 1;  
        uint32_t numElements : 31; 
        constexpr ArrayInfo(bool isPacked, uint32_t numElements) : isPacked(isPacked), numElements(numElements) {}
    };
    union
    {
        EmptyInfo  emptyInfo;
        MemberInfo memberInfo;
        StructInfo structInfo;
        ArrayInfo  arrayInfo;
    };
 
    constexpr TypeInfo()
        : hasLink(false), type(TypeCategory::TypeInvalid), numberOfChildren(0), sizeInBytes(0), emptyInfo()
    {
        static_assert(sizeof(TypeInfo) == 8, "Size must be 8 bytes");
    }
 
    constexpr TypeInfo(TypeCategory type, uint16_t sizeInBytes, StructInfo structInfo)
        : hasLink(false), type(type), numberOfChildren(0), sizeInBytes(sizeInBytes), structInfo(structInfo)
    {}
 
    constexpr TypeInfo(TypeCategory type, uint16_t sizeInBytes, MemberInfo member)
        : hasLink(true), type(type), linkIndex(0), sizeInBytes(sizeInBytes), memberInfo(member)
    {}
 
    constexpr TypeInfo(TypeCategory type, uint16_t sizeInBytes, uint8_t numberOfChildren, ArrayInfo arrayInfo)
        : hasLink(false), type(type), numberOfChildren(numberOfChildren), sizeInBytes(sizeInBytes), arrayInfo(arrayInfo)
    {}
 
    constexpr TypeInfo(TypeCategory type, uint16_t sizeInBytes)
        : hasLink(true), type(type), linkIndex(0), sizeInBytes(sizeInBytes), emptyInfo()
    {}
 
    [[nodiscard]] constexpr auto getNumberOfChildren() const { return numberOfChildren; }
 
    [[nodiscard]] constexpr bool setNumberOfChildren(size_t numChildren)
    {
        if (numChildren > static_cast<decltype(numberOfChildren)>(~0ull)) // MaxValue<uint8_t>
            return false;
        numberOfChildren = static_cast<decltype(numberOfChildren)>(numChildren);
        return true;
    }
 
    [[nodiscard]] constexpr bool hasValidLinkIndex() const { return hasLink and linkIndex > 0; }
 
    [[nodiscard]] constexpr bool needsLinking() const { return hasLink and linkIndex == 0; }
 
    [[nodiscard]] constexpr auto getLinkIndex() const { return linkIndex; }
 
    [[nodiscard]] constexpr bool setLinkIndex(ssize_t newLinkIndex)
    {
        if (newLinkIndex > static_cast<decltype(linkIndex)>(~0ull))
            return false;
        linkIndex = static_cast<decltype(linkIndex)>(newLinkIndex);
        return true;
    }
 
    [[nodiscard]] constexpr bool isPrimitiveType() const { return isPrimitiveCategory(type); }
 
    [[nodiscard]] constexpr bool isPrimitiveOrPackedStruct() const
    {
        if (isPrimitiveType())
            return true;
        return (type == Reflection::TypeCategory::TypeStruct) and structInfo.isPacked;
    }
 
    [[nodiscard]] static constexpr bool isPrimitiveCategory(TypeCategory category)
    {
        return category >= TypeCategory::TypeBOOL and category <= TypeCategory::TypeDOUBLE64;
    }
};
 
template <typename T>
struct Reflect;
 
template <typename T, typename SFINAESelector = void>
struct ExtendedTypeInfo;
 
//-----------------------------------------------------------------------------------------------------------
// Primitive Types Support
//-----------------------------------------------------------------------------------------------------------
 
struct ReflectPrimitive
{
    template <typename TypeVisitor>
    [[nodiscard]] static constexpr bool build(TypeVisitor&)
    {
        return true;
    }
};
 
// clang-format off
template <> struct Reflect<char>     : public ReflectPrimitive {static constexpr auto getCategory(){return TypeCategory::TypeINT8;}};
template <> struct Reflect<uint8_t>  : public ReflectPrimitive {static constexpr auto getCategory(){return TypeCategory::TypeUINT8;}};
template <> struct Reflect<uint16_t> : public ReflectPrimitive {static constexpr auto getCategory(){return TypeCategory::TypeUINT16;}};
template <> struct Reflect<uint32_t> : public ReflectPrimitive {static constexpr auto getCategory(){return TypeCategory::TypeUINT32;}};
template <> struct Reflect<uint64_t> : public ReflectPrimitive {static constexpr auto getCategory(){return TypeCategory::TypeUINT64;}};
template <> struct Reflect<int8_t>   : public ReflectPrimitive {static constexpr auto getCategory(){return TypeCategory::TypeINT8;}};
template <> struct Reflect<int16_t>  : public ReflectPrimitive {static constexpr auto getCategory(){return TypeCategory::TypeINT16;}};
template <> struct Reflect<int32_t>  : public ReflectPrimitive {static constexpr auto getCategory(){return TypeCategory::TypeINT32;}};
template <> struct Reflect<int64_t>  : public ReflectPrimitive {static constexpr auto getCategory(){return TypeCategory::TypeINT64;}};
template <> struct Reflect<float>    : public ReflectPrimitive {static constexpr auto getCategory(){return TypeCategory::TypeFLOAT32;}};
template <> struct Reflect<double>   : public ReflectPrimitive {static constexpr auto getCategory(){return TypeCategory::TypeDOUBLE64;}};
template <> struct Reflect<bool>     : public ReflectPrimitive {static constexpr auto getCategory(){return TypeCategory::TypeBOOL;}};
 
template <typename T> struct IsPrimitive { static constexpr bool value = TypeInfo::isPrimitiveCategory(Reflect<T>::getCategory()); };
template <typename T> struct IsStruct { static constexpr bool value = Reflect<T>::getCategory() == TypeCategory::TypeStruct; };
 
// clang-format on
 
template <typename T>
struct ExtendedTypeInfo<T, typename SC::TypeTraits::EnableIf<IsPrimitive<T>::value>::type>
{
    // Primitive types are packed
    static constexpr bool IsPacked = true;
};
 
//-----------------------------------------------------------------------------------------------------------
// Arrays Support
//-----------------------------------------------------------------------------------------------------------
template <typename T, size_t N>
struct Reflect<T[N]>
{
    static constexpr TypeCategory getCategory() { return TypeCategory::TypeArray; }
 
    template <typename TypeVisitor>
    [[nodiscard]] static constexpr bool build(TypeVisitor& builder)
    {
        using Type = typename TypeVisitor::Type;
 
        // Add array type
        constexpr bool isPacked = ExtendedTypeInfo<T>::IsPacked;
        if (not builder.addType(Type::template createArray<T[N]>("Array", 1, TypeInfo::ArrayInfo{isPacked, N})))
            return false;
 
        // Add dependent item type
        if (not builder.addType(Type::template createGeneric<T>()))
            return false;
 
        return true;
    }
};
 
template <typename T, int N>
struct ExtendedTypeInfo<T[N]>
{
    // Arrays are packed if T is packed
    static constexpr bool IsPacked = ExtendedTypeInfo<T>::IsPacked;
};
 
//-----------------------------------------------------------------------------------------------------------
// Structs Support
//-----------------------------------------------------------------------------------------------------------
template <typename Type>
struct ReflectStruct
{
    using T = Type;
 
    [[nodiscard]] static constexpr TypeCategory getCategory() { return TypeCategory::TypeStruct; }
 
    template <typename TypeVisitor>
    [[nodiscard]] static constexpr bool build(TypeVisitor& builder)
    {
        // Add struct type
        if (not builder.addType(TypeVisitor::Type::template createStruct<T>()))
            return false;
 
        // Add all struct member
        if (not Reflect<Type>::visit(builder))
            return false;
        return true;
    }
};
 
template <typename T>
struct ExtendedStructTypeInfo
{
    size_t memberSizeSum = 0;
    bool   IsPacked      = false;
 
    constexpr ExtendedStructTypeInfo()
    {
        // Let's call operator() for each member
        if (Reflect<T>::visit(*this))
        {
            // Structs are packed if all of its members are packed (checked in `operator()`)
            // and in addition to that, summed size of all members is `==` `sizeof(T)`
            IsPacked = memberSizeSum == sizeof(T);
        }
    }
 
    template <typename R, int N>
    constexpr bool operator()(int memberTag, R T::* member, const char (&name)[N], size_t offset)
    {
        SC_COMPILER_UNUSED(memberTag);
        SC_COMPILER_UNUSED(name);
        SC_COMPILER_UNUSED(member);
        SC_COMPILER_UNUSED(offset);
        if (not ExtendedTypeInfo<R>().IsPacked)
        {
            return false; // If a given type is not packed, let's stop iterating
        }
        memberSizeSum += sizeof(R);
        return true; // continue iterating
    }
};
 
template <typename T, typename SFINAESelector>
struct ExtendedTypeInfo
{
    // Struct is packed if all of its members are packed and sum of their size equals size of struct.
    static constexpr bool IsPacked = ExtendedStructTypeInfo<T>().IsPacked;
};
 
template <typename MemberVisitor, typename Container, typename ItemType, int N>
struct VectorArrayVTable
{
    static constexpr bool build(MemberVisitor&) { return true; }
};
} // namespace Reflection
} // namespace SC
 
// Handy Macros to avoid some typing when wrapping structs
 
#define SC_REFLECT_STRUCT_VISIT(StructName)                                                                            \
    template <>                                                                                                        \
    struct SC::Reflection::Reflect<StructName> : SC::Reflection::ReflectStruct<StructName>                             \
    {                                                                                                                  \
        template <typename TypeVisitor>                                                                                \
        static constexpr bool visit(TypeVisitor&& builder)                                                             \
        {                                                                                                              \
            SC_COMPILER_WARNING_PUSH_OFFSETOF                                                                          \
            return true
 
#define SC_REFLECT_STRUCT_FIELD(MEMBER_TAG, MEMBER)                                                                    \
    and builder(MEMBER_TAG, &T::MEMBER, #MEMBER, SC_COMPILER_OFFSETOF(T, MEMBER))
 
#define SC_REFLECT_STRUCT_LEAVE()                                                                                      \
    ;                                                                                                                  \
    SC_COMPILER_WARNING_POP                                                                                            \
    }                                                                                                                  \
    }                                                                                                                  \
    ;