TypedElementDataStorageCompatibilityInterface.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Elements/Interfaces/TypedElementDataStorageInterface.h"
#include "Features/IModularFeature.h"
#include "Templates/Function.h"
#include "UObject/Interface.h"
#include "UObject/ObjectKey.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ObjectPtr.h"
#include "UObject/StrongObjectPtr.h"
#include "UObject/WeakObjectPtrTemplates.h"
 
namespace UE::Editor::DataStorage
{
class ICompatibilityProvider : public IModularFeature
{
public:
    using ObjectRegistrationFilter = TFunction<bool(const ICompatibilityProvider&, const UObject*)>;
    using ObjectToRowDealiaser = TFunction<RowHandle(const ICompatibilityProvider&, const UObject*)>;
    
    inline static const FName ObjectMappingDomain = "Object";
 
    template<typename ObjectType>
    RowHandle AddCompatibleObject(ObjectType&& Object);
    
    template<typename ObjectType>
    void RemoveCompatibleObject(ObjectType&& Object);
 
    template<typename ObjectType>
    RowHandle FindRowWithCompatibleObject(ObjectType&& Object) const;
 
    virtual void RegisterRegistrationFilter(ObjectRegistrationFilter Filter) = 0;
    virtual void RegisterDealiaserCallback(ObjectToRowDealiaser Dealiaser) = 0;
    virtual void RegisterTypeTableAssociation(TWeakObjectPtr<UStruct> TypeInfo, TableHandle Table) = 0;
 
    virtual RowHandle AddCompatibleObjectExplicit(UObject* Object) = 0;
    virtual RowHandle AddCompatibleObjectExplicit(void* Object, TWeakObjectPtr<const UScriptStruct> TypeInfo) = 0;
    
    virtual void RemoveCompatibleObjectExplicit(UObject* Object) = 0;
    virtual void RemoveCompatibleObjectExplicit(void* Object) = 0;
 
    virtual RowHandle FindRowWithCompatibleObjectExplicit(const UObject* Object) const = 0;
    virtual RowHandle FindRowWithCompatibleObjectExplicit(const void* Object) const = 0;
 
    virtual bool SupportsExtension(FName Extension) const = 0;
    virtual void ListExtensions(TFunctionRef<void(FName)> Callback) const = 0;
};
 
template<typename Type> Type* GetRawPointer(const TWeakObjectPtr<Type> Object)  { return Object.Get(); }
template<typename Type> Type* GetRawPointer(const TObjectPtr<Type> Object)      { return Object.Get(); }
template<typename Type> Type* GetRawPointer(const TStrongObjectPtr<Type> Object){ return Object.Get(); }
template<typename Type> Type* GetRawPointer(const TObjectKey<Type> Object)      { return Object.ResolveObjectPtr(); }
template<typename Type> Type* GetRawPointer(const TUniquePtr<Type> Object)      { return Object.Get(); }
template<typename Type> Type* GetRawPointer(const TSharedPtr<Type> Object)      { return Object.Get(); }
#if UE_ENABLE_NOTNULL_WRAPPER
template<typename Type> Type* GetRawPointer(TNotNull<Type*> Object)             { return Object; }
#endif
template<typename Type> Type* GetRawPointer(Type* Object)                       { return Object; }
template<typename Type> Type* GetRawPointer(Type& Object)                       { return &Object; }
 
template<typename ObjectType>
RowHandle ICompatibilityProvider::AddCompatibleObject(ObjectType&& Object)
{
    auto RawPointer = GetRawPointer(Forward<ObjectType>(Object));
    using BaseType = std::remove_cv_t<std::remove_pointer_t<decltype(RawPointer)>>;
 
    if constexpr (std::is_base_of_v<UObject, BaseType>)
    {
        return AddCompatibleObjectExplicit(RawPointer);
    }
    else
    {
        return AddCompatibleObjectExplicit(RawPointer, BaseType::StaticStruct());
    }
}
 
template<typename ObjectType>
void ICompatibilityProvider::RemoveCompatibleObject(ObjectType&& Object)
{
    RemoveCompatibleObjectExplicit(GetRawPointer(Forward<ObjectType>(Object)));
}
 
template<typename ObjectType>
RowHandle ICompatibilityProvider::FindRowWithCompatibleObject(ObjectType&& Object) const
{
    return FindRowWithCompatibleObjectExplicit(GetRawPointer(Forward<ObjectType>(Object)));
}
 
template<typename Subsystem>
struct TTypedElementSubsystemTraits final
{
    template<typename T, typename = void>
    struct HasRequiresGameThreadVariable 
    { 
        static constexpr bool bAvailable = false; 
    };
    template<typename T>
    struct HasRequiresGameThreadVariable <T, decltype((void)T::bRequiresGameThread)>
    { 
        static constexpr bool bAvailable = true; 
    };
 
    template<typename T, typename = void>
    struct HasIsHotReloadableVariable
    { 
        static constexpr bool bAvailable = false;
    };
    template<typename T>
    struct HasIsHotReloadableVariable <T, decltype((void)T::bIsHotReloadable)>
    { 
        static constexpr bool bAvailable = true;
    };
 
    static constexpr bool RequiresGameThread()
    {
        if constexpr (HasRequiresGameThreadVariable<Subsystem>::bAvailable)
        {
            return Subsystem::bRequiresGameThread;
        }
        else
        {
            static_assert(HasRequiresGameThreadVariable<Subsystem>::bAvailable, "Subsystem provided to the Typed Elements did not "
                "have a 'static constexpr bool bRequiresGameThread = true|false` declared or have a specialization for "
                "TTypedElementSubsystemTraits.");
            return true;
        }
    }
 
    static constexpr bool IsHotReloadable()
    {
        if constexpr (HasIsHotReloadableVariable<Subsystem>::bAvailable)
        {
            return Subsystem::bIsHotReloadable;
        }
        else
        {
            static_assert(HasIsHotReloadableVariable<Subsystem>::bAvailable, "Subsystem provided to the Typed Elements did not "
                "have a 'static constexpr bool bIsHotReloadable = true|false` declared or have a specialization for "
                "TTypedElementSubsystemTraits.");
            return false;
        }
    }
};
} // namespace UE::Editor::DataStorage