SubClassOf.h

#pragma once
 
#include "krpch.h"
 
#include "Class.h"
#include "Field.h"
 
namespace Karma
{
    template<bool Predicate, typename TrueClass, typename FalseClass>
    class TChooseClass;
 
    template<typename TrueClass, typename FalseClass>
    class TChooseClass<true, TrueClass, FalseClass>
    {
    public:
        typedef TrueClass Result;
    };
 
    template<typename TrueClass, typename FalseClass>
    class TChooseClass<false, TrueClass, FalseClass>
    {
    public:
        typedef FalseClass Result;
    };
 
    template <typename T>
    struct TIsTSubclassOf
    {
        enum { Value = false };
    };
 
    template<typename DerivedType, typename BaseType>
    struct TIsDerivedFrom
    {
        // Different size types so we can compare their sizes later.
        typedef char No[1];
        typedef char Yes[2];
 
        // Overloading Test() s.t. only calling it with something that is
        // a BaseType (or inherited from the BaseType) will return a Yes.
        static Yes& Test(BaseType*);
        static Yes& Test(const BaseType*);
        static No& Test(...);
 
        // Makes a DerivedType ptr.
        static DerivedType* DerivedTypePtr() { return nullptr; }
 
    public:
        // Test the derived type pointer. If it inherits from BaseType, the Test( BaseType* ) 
        // will be chosen. If it does not, Test( ... ) will be chosen.
        static constexpr bool Value = sizeof(Test(DerivedTypePtr())) == sizeof(Yes);
 
        static constexpr bool IsDerived = Value;
    };
 
    template<class TClass>
    class TSubclassOf
    {
    public:
        typedef typename TChooseClass<TIsDerivedFrom<TClass, FField>::IsDerived, FFieldClass, UClass>::Result TClassType;
        typedef typename TChooseClass<TIsDerivedFrom<TClass, FField>::IsDerived, FField, UObject>::Result TBaseType;
 
    private:
        template <class TClassA>
        friend class TSubclassOf;
 
    public:
        inline TSubclassOf() :
            Class(nullptr)
        {
        }
 
        inline TSubclassOf(TClassType* From) :
            Class(From)
        {
        }
 
        template <
            typename U,
            std::enable_if_t<
            !TIsTSubclassOf<std::decay_t<U>>::Value,
            decltype(ImplicitConv<TClassType*>(std::declval<U>()))
            >* = nullptr
        >
        inline TSubclassOf(U&& From)
            : Class(From)
        {
        }
 
        template <class TClassA, class = decltype(ImplicitConv<TClass*>((TClassA*)nullptr))>
        inline TSubclassOf(const TSubclassOf<TClassA>& From) :
            Class(*From)
        {
        }
 
        template <class TClassA, class = decltype(ImplicitConv<TClass*>((TClassA*)nullptr))>
        inline TSubclassOf& operator=(const TSubclassOf<TClassA>& From)
        {
            Class = *From;
            return *this;
        }
 
        inline TSubclassOf& operator=(TClassType* From)
        {
            Class = From;
            return *this;
        }
 
        template <
            typename U,
            std::enable_if_t<
            !TIsTSubclassOf<std::decay_t<U>>::Value,
            decltype(ImplicitConv<TClassType*>(std::declval<U>()))
            >* = nullptr
        >
        inline TSubclassOf& operator=(U&& From)
        {
            Class = From;
            return *this;
        }
 
        inline TClassType* operator*() const
        {
            if (!Class || !Class->IsChildOf(TClass::StaticClass()))
            {
                return nullptr;
            }
            return Class;
        }
 
        inline TClassType* Get() const
        {
            return **this;
        }
 
        inline TClassType* operator->() const
        {
            return **this;
        }
 
        inline operator TClassType* () const
        {
            return **this;
        }
 
        inline TClass* GetDefaultObject() const
        {
            TBaseType* Result = nullptr;
            if (Class)
            {
                Result = Class->GetDefaultObject();
                check(Result && Result->IsA(TClass::StaticClass()));
            }
            return (TClass*)Result;
        }
        /*
        friend FArchive& operator<<(FArchive& Ar, TSubclassOf& SubclassOf)
        {
            Ar << SubclassOf.Class;
            return Ar;
        }
 
        friend uint32 GetTypeHash(const TSubclassOf& SubclassOf)
        {
            return GetTypeHash(SubclassOf.Class);
        }*/
 
    private:
        TClassType* Class;
    };
 
    template <typename T>
    struct TIsTSubclassOf<TSubclassOf<T>>
    {
        enum { Value = true };
    };
}