SubclassOf.h

/******************************************************************
 * SubclassOf
 *
 *******************************************************************/
#pragma once
 
#include "LkEngine/Core/Template/LkTemplate.h"
#include "LkEngine/Core/LObject/LClass.h"
#include "LkEngine/Core/LObject/ObjectPtr.h"
 
 
namespace LkEngine {
 
    template <typename T>
    class TSubclassOf;
 
    template <typename T>
    struct TIsTSubclassOf
    {
        enum { Value = false };
    };
 
    template <typename T> struct TIsTSubclassOf<               TSubclassOf<T>> { enum { Value = true }; };
    template <typename T> struct TIsTSubclassOf<const          TSubclassOf<T>> { enum { Value = true }; };
    template <typename T> struct TIsTSubclassOf<      volatile TSubclassOf<T>> { enum { Value = true }; };
    template <typename T> struct TIsTSubclassOf<const volatile TSubclassOf<T>> { enum { Value = true }; };
 
    template <typename T>
    class TSubclassOf
    {
    public:
        TSubclassOf() = default;
        TSubclassOf(TSubclassOf&&) = default;
        TSubclassOf(const TSubclassOf&) = default;
        ~TSubclassOf() = default;
 
        TSubclassOf& operator=(TSubclassOf&&) = default;
        TSubclassOf& operator=(const TSubclassOf&) = default;
 
        FORCEINLINE TSubclassOf(LClass* From)
            : Class(From)
        {
        }
 
        template<typename R, 
                std::enable_if_t<
                    !TIsTSubclassOf<std::decay_t<R>>::Value, decltype(ImplicitConv<LClass*>(std::declval<R>())) 
                >* = nullptr>
            FORCEINLINE TSubclassOf(R&& From)
            : Class(From)
        {
        }
 
        FORCEINLINE TSubclassOf& operator=(LClass* From)
        {
            Class = From;
            return *this;
        }
 
        template<typename R,
                std::enable_if_t<
                    !TIsTSubclassOf<std::decay_t<R>>::Value, decltype(ImplicitConv<LClass*>(std::declval<R>()))
                >* = nullptr
        >
        FORCEINLINE TSubclassOf& operator=(R&& From)
        {
            Class = From;
            return *this;
        }
 
        FORCEINLINE LClass* operator*() const
        {
            if (!Class || !Class->IsChildOf(T::StaticClass()))
            {
                return nullptr;
            }
 
            return Class;
        }
 
        FORCEINLINE LClass* Get() const
        {
            return **this;
        }
 
        FORCEINLINE LClass* operator->() const
        {
            return **this;
        }
 
        FORCEINLINE operator LClass* () const
        {
            return **this;
        }
 
    private:
        TObjectPtr<LClass> Class = nullptr;
 
        template <typename R>
        friend class TSubclassOf;
    };
 
}