SubClassOf.h

Go to the documentation of this file.

 
#pragma once
 
#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(...);

        static DerivedType* DerivedTypePtr() { return nullptr; }
 
    public:
        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();
                KR_CORE_ASSERT(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 };
    };
}