TypeContainer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Templates/PointerIsConvertibleFromTo.h"
#include "Misc/AssertionMacros.h"
#include "Templates/UnrealTypeTraits.h"
#include "Containers/UnrealString.h"
#include "Templates/Function.h"
#include "Containers/Map.h"
#include "Templates/SharedPointer.h"
#include "HAL/TlsAutoCleanup.h"
#include "Misc/ScopeLock.h"
 
enum class ETypeContainerScope
{
    Instance,
 
    Process,
 
    Thread,
};
 
 
template<ESPMode Mode = ESPMode::ThreadSafe>
class TTypeContainer
{
    class IInstanceProvider
    {
    public:
 
        virtual ~IInstanceProvider() { }
 
        virtual TSharedPtr<void, Mode> GetInstance() = 0;
    };
 
    template<class T>
    struct TFunctionInstanceProvider
        : public IInstanceProvider
    {
        TFunctionInstanceProvider(TFunction<TSharedPtr<void, Mode>()>&& InCreateFunc)
            : CreateFunc(MoveTemp(InCreateFunc))
        { }
 
        virtual ~TFunctionInstanceProvider() override { }
 
        virtual TSharedPtr<void, Mode> GetInstance() override
        {
            return CreateFunc();
        }
 
        TFunction<TSharedPtr<void, Mode>()> CreateFunc;
    };
 
 
    template<class T>
    struct TSharedInstanceProvider
        : public IInstanceProvider
    {
        TSharedInstanceProvider(const TSharedRef<T, Mode>& InInstance)
            : Instance(InInstance)
        { }
 
        virtual ~TSharedInstanceProvider() { }
 
        virtual TSharedPtr<void, Mode> GetInstance() override
        {
            return Instance;
        }
 
        TSharedRef<T, Mode> Instance;
    };
 
 
    struct FThreadInstanceProvider
        : public IInstanceProvider
    {
        FThreadInstanceProvider(TFunction<TSharedPtr<void, Mode>()>&& InCreateFunc)
            : CreateFunc(MoveTemp(InCreateFunc))
            , TlsSlot(FPlatformTLS::AllocTlsSlot())
        { }
 
        virtual ~FThreadInstanceProvider() override
        {
            FPlatformTLS::FreeTlsSlot(TlsSlot);
        }
 
        TFunction<TSharedPtr<void, Mode>()> CreateFunc;
        uint32 TlsSlot;
    };
 
 
    template<class T>
    struct TThreadInstanceProvider
        : public FThreadInstanceProvider
    {
        typedef TTlsAutoCleanupValue<TSharedPtr<T, Mode>> TlsValueType;
 
        TThreadInstanceProvider(TFunction<TSharedPtr<void, Mode>()>&& InCreateFunc)
            : FThreadInstanceProvider(MoveTemp(InCreateFunc))
        { }
 
        virtual ~TThreadInstanceProvider() override { }
 
        virtual TSharedPtr<void, Mode> GetInstance() override
        {
            auto TlsValue = (TlsValueType*)FPlatformTLS::GetTlsValue(this->TlsSlot);
 
            if (TlsValue == nullptr)
            {
                TlsValue = new TlsValueType(StaticCastSharedPtr<T>(this->CreateFunc()));
                TlsValue->Register();
                FPlatformTLS::SetTlsValue(this->TlsSlot, TlsValue);
            }
 
            return TlsValue->Get();
        }
    };
 
public:
 
    template<class R>
    TSharedRef<R, Mode> GetInstance() const
    {
        FScopeLock Lock(&CriticalSection);
        {
            const TSharedPtr<IInstanceProvider>& Provider = Providers.FindRef(TNameOf<R>::GetName());
            check(Provider.IsValid());
 
            return StaticCastSharedPtr<R>(Provider->GetInstance()).ToSharedRef();
        }
    }
 
    template<class R>
    TSharedRef<R, Mode> GetInstanceRef() const
    {
        return GetInstance<R>().ToSharedRef();
    }
 
    template<class R>
    bool IsRegistered() const
    {
        FScopeLock Lock(&CriticalSection);
        {
            return Providers.Contains(TNameOf<R>::GetName());
        }
    }
 
    template<class R, class T, typename... P>
    void RegisterClass(ETypeContainerScope Scope = ETypeContainerScope::Process)
    {
        static_assert(TPointerIsConvertibleFromTo<T, R>::Value, "T must implement R");
 
        TSharedPtr<IInstanceProvider> Provider;
        
        switch(Scope)
        {
        case ETypeContainerScope::Instance:
            Provider = MakeShareable(
                new TFunctionInstanceProvider<T>(
                    [this]() -> TSharedPtr<void, Mode> {
                        return MakeShareable(new T(GetInstance<P>()...));
                    }
                )
            );
            break;
 
        case ETypeContainerScope::Thread:
            Provider = MakeShareable(
                new TThreadInstanceProvider<T>(
                    [this]() -> TSharedPtr<void, Mode> {
                        return MakeShareable(new T(GetInstance<P>()...));
                    }
                )
            );
            break;
 
        default:
            Provider = MakeShareable(
                new TSharedInstanceProvider<T>(
                    MakeShareable(new T(GetInstance<P>()...))
                )
            );
            break;
        }
 
        AddProvider(TNameOf<R>::GetName(), Provider);
    }
 
    template<class R, class D, typename... P>
    void RegisterDelegate(D Delegate)
    {
        static_assert(std::is_same_v<TSharedRef<R, Mode>, typename D::RetValType>, "Delegate return type must be TSharedPtr<R>");
 
        TSharedPtr<IInstanceProvider> Provider = MakeShareable(
            new TFunctionInstanceProvider<R>(
                [this, Delegate]() -> TSharedPtr<void, Mode> {
                    return Delegate.Execute(GetInstance<P>()...);
                }
            )
        );
 
        AddProvider(TNameOf<R>::GetName(), Provider);
    }
 
    template<class R>
    void RegisterFactory(const TFunction<TSharedRef<R, Mode>()>& CreateFunc)
    {
        TSharedPtr<IInstanceProvider> Provider = MakeShareable(
            new TFunctionInstanceProvider<R>(
                [=, this]() -> TSharedPtr<void, Mode> {
                    return CreateFunc();
                }
            )
        );
 
        AddProvider(TNameOf<R>::GetName(), Provider);
    }
 
    template<class R, typename P0, typename... P>
    void RegisterFactory(const TFunction<TSharedRef<R, Mode>(TSharedRef<P0, Mode>, TSharedRef<P, Mode>...)>& CreateFunc)
    {
        TSharedPtr<IInstanceProvider> Provider = MakeShareable(
            new TFunctionInstanceProvider<R>(
                [=, this]() -> TSharedPtr<void, Mode> {
                    return CreateFunc(GetInstance<P0>(), GetInstance<P>()...);
                }
            )
        );
 
        AddProvider(TNameOf<R>::GetName(), Provider);
    }
 
#if (defined(_MSC_VER) && _MSC_VER >= 1900) || defined(__clang__)
    template<class R, typename... P>
    void RegisterFactory(TSharedRef<R, Mode> (*CreateFunc)(TSharedRef<P, Mode>...))
    {
        TSharedPtr<IInstanceProvider> Provider = MakeShareable(
            new TFunctionInstanceProvider<R>(
                [this, CreateFunc]() -> TSharedPtr<void, Mode> {
                    return CreateFunc(GetInstance<P>()...);
                }
            )
        );
 
        AddProvider(TNameOf<R>::GetName(), Provider);
    }
#endif
 
    template<class R, class T>
    void RegisterInstance(const TSharedRef<T, Mode>& Instance)
    {
        static_assert(TPointerIsConvertibleFromTo<T, R>::Value, "T must implement R");
 
        AddProvider(TNameOf<R>::GetName(), MakeShareable(new TSharedInstanceProvider<R>(Instance)));
    }
 
    template<class R>
    void Unregister()
    {
        FScopeLock Lock(&CriticalSection);
        {
            Providers.Remove(TNameOf<R>::GetName());
        }
    }
 
protected:
 
    void AddProvider(const TCHAR* Name, const TSharedPtr<IInstanceProvider>& Provider)
    {
        FScopeLock Lock(&CriticalSection);
        {
            Providers.Add(Name, Provider);
        }
    }
 
private:
 
    mutable FCriticalSection CriticalSection;
 
    TMap<FString, TSharedPtr<IInstanceProvider>> Providers;
};
 
 
class FTypeContainer : public TTypeContainer<ESPMode::ThreadSafe> { };