TypedElementList.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/Set.h"
#include "CoreMinimal.h"
#include "Delegates/Delegate.h"
#include "Delegates/DelegateCombinations.h"
#include "Elements/Framework/TypedElementCounter.h"
#include "Elements/Framework/TypedElementHandle.h"
#include "Elements/Framework/TypedElementLimits.h"
#include "Elements/Framework/TypedElementListFwd.h"
#include "HAL/Platform.h"
#include "Templates/Casts.h"
#include "Templates/Function.h"
#include "Templates/SharedPointer.h"
#include "Templates/SubclassOf.h"
#include "Templates/UniquePtr.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/NameTypes.h"
#include "UObject/WeakObjectPtr.h"
#include "UObject/WeakObjectPtrTemplates.h"
 
class UInterface;
class UObject;
class UTypedElementRegistry;
struct FTypedElementId;
 
namespace TypedElementList_Private
{
 
TYPEDELEMENTFRAMEWORK_API void GetElementImpl(const UTypedElementRegistry* InRegistry, const FTypedElementHandle& InElementHandle, const TSubclassOf<UInterface>& InBaseInterfaceType, FTypedElement& OutElement);
 
TYPEDELEMENTFRAMEWORK_API void GetElementImpl(const UTypedElementRegistry* InRegistry, const FScriptTypedElementHandle& InElementHandle, const TSubclassOf<UInterface>& InBaseInterfaceType, FTypedElement& OutElement);
 
template <typename BaseInterfaceType, class HandleType>
inline void GetElement(const UTypedElementRegistry* InRegistry, const HandleType& InElementHandle, TTypedElement<BaseInterfaceType>& OutElement)
{
    static_assert(sizeof(TTypedElement<BaseInterfaceType>) == sizeof(FTypedElement), "All TTypedElement instances must be the same size for this cast implementation to work!");
    GetElementImpl(InRegistry, InElementHandle, BaseInterfaceType::UClassType::StaticClass(), reinterpret_cast<FTypedElement&>(OutElement));
}
 
template <typename BaseInterfaceType, class HandleType>
inline TTypedElement<BaseInterfaceType> GetElement(const UTypedElementRegistry* InRegistry, const HandleType& InElementHandle)
{
    TTypedElement<BaseInterfaceType> Element;
    GetElement(InRegistry, InElementHandle, Element);
    return Element;
}
 
} // namespace TypedElementList_Private
 
 
template<class HandleType>
class TTypedElementList final : public TSharedFromThis<TTypedElementList<HandleType>>
{
public:
 
    using FHandleType = HandleType;
    using TTypedElementListRef = TSharedRef<TTypedElementList>;
    using TTypedElementListConstRef = TSharedRef<const TTypedElementList>;
 
 
    TYPEDELEMENTFRAMEWORK_API ~TTypedElementList();
 
    TYPEDELEMENTFRAMEWORK_API TTypedElementListRef Clone() const;
 
    inline HandleType operator[](const int32 InIndex) const
    {
        return GetElementHandleAt(InIndex);
    }
 
    inline HandleType GetElementHandleAt(const int32 InIndex) const
    {
        return ElementHandles[InIndex];
    }
 
    template <typename BaseInterfaceType>
    inline TTypedElement<BaseInterfaceType> GetElementAt(const int32 InIndex) const
    {
        return GetElement<BaseInterfaceType>(GetElementHandleAt(InIndex));
    }
 
    template <typename BaseInterfaceType>
    inline void GetElementAt(const int32 InIndex, TTypedElement<BaseInterfaceType>& OutElement) const
    {
        GetElement(GetElementHandleAt(InIndex), OutElement);
    }
 
    template <typename BaseInterfaceType>
    inline TTypedElement<BaseInterfaceType> GetElement(const HandleType& InElementHandle) const
    {
        return TypedElementList_Private::GetElement<BaseInterfaceType>(Registry.Get(), InElementHandle);
    }
 
    template <typename BaseInterfaceType>
    inline void GetElement(const HandleType& InElementHandle, TTypedElement<BaseInterfaceType>& OutElement) const
    {
        TypedElementList_Private::GetElement(Registry.Get(), InElementHandle, OutElement);
    }
 
    template <typename BaseInterfaceType>
    TTypedElement<BaseInterfaceType> GetTopElement() const
    {
        TTypedElement<BaseInterfaceType> TempElement;
        for (int32 ElementIndex = 0; ElementIndex < Num(); ++ElementIndex)
        {
            GetElementAt(ElementIndex, TempElement);
            if (TempElement)
            {
                break;
            }
        }
        return TempElement;
    }
 
    template <typename BaseInterfaceType>
    TTypedElement<BaseInterfaceType> GetTopElement(TFunctionRef<bool (const TTypedElement<BaseInterfaceType>&)> Predicate) const
    {
        TTypedElement<BaseInterfaceType> TempElement;
        TTypedElement<BaseInterfaceType> ElementToReturn;
        for (int32 ElementIndex = 0; ElementIndex < Num(); ++ElementIndex)
        {
            GetElementAt(ElementIndex, TempElement);
            if (TempElement && Predicate(TempElement))
            {
                ElementToReturn = MoveTemp(TempElement);
                break;
            }
        }
        return ElementToReturn;
    }
 
 
    template <typename BaseInterfaceType>
    TTypedElement<BaseInterfaceType> GetBottomElement() const
    {
        TTypedElement<BaseInterfaceType> TempElement;
        for (int32 ElementIndex = Num() - 1; ElementIndex >= 0; --ElementIndex)
        {
            GetElementAt(ElementIndex, TempElement);
            if (TempElement)
            {
                break;
            }
        }
        return TempElement;
    }
 
    template <typename BaseInterfaceType>
    TTypedElement<BaseInterfaceType> GetBottomElement(TFunctionRef<bool (const TTypedElement<BaseInterfaceType>&)> Predicate) const
    {
        TTypedElement<BaseInterfaceType> TempElement;
        TTypedElement<BaseInterfaceType> ElementToReturn;
        for (int32 ElementIndex = Num() - 1; ElementIndex >= 0; --ElementIndex)
        {
            GetElementAt(ElementIndex, TempElement);
            if (TempElement && Predicate(TempElement))
            {
                ElementToReturn = MoveTemp(TempElement);
                break;
            }
        }
        return ElementToReturn;
    }
 
 
 
    template <typename BaseInterfaceType>
    BaseInterfaceType* GetElementInterface(const FTypedElementHandle& InElementHandle) const
    {
        return Cast<BaseInterfaceType>(GetElementInterface(InElementHandle, BaseInterfaceType::UClassType::StaticClass()));
    }
 
    TYPEDELEMENTFRAMEWORK_API UObject* GetElementInterface(const HandleType& InElementHandle, const TSubclassOf<UInterface>& InBaseInterfaceType) const;
 
    TYPEDELEMENTFRAMEWORK_API bool HasElements(const TSubclassOf<UInterface>& InBaseInterfaceType = {}) const;
 
    TYPEDELEMENTFRAMEWORK_API int32 CountElements(const TSubclassOf<UInterface>& InBaseInterfaceType = {}) const;
 
    TYPEDELEMENTFRAMEWORK_API bool HasElementsOfType(const FName InElementTypeName) const;
    TYPEDELEMENTFRAMEWORK_API bool HasElementsOfType(const FTypedHandleTypeId InElementTypeId) const;
 
    TYPEDELEMENTFRAMEWORK_API int32 CountElementsOfType(const FName InElementTypeName) const;
    TYPEDELEMENTFRAMEWORK_API int32 CountElementsOfType(const FTypedHandleTypeId InElementTypeId) const;
 
    TYPEDELEMENTFRAMEWORK_API TArray<HandleType> GetElementHandles(const TSubclassOf<UInterface>& InBaseInterfaceType = {}) const;
 
    template <typename ArrayAllocator>
    void GetElementHandles(TArray<HandleType, ArrayAllocator>& OutArray, const TSubclassOf<UInterface>& InBaseInterfaceType = {}) const
    {
        OutArray.Reset();
        OutArray.Reserve(ElementHandles.Num());
        ForEachElementHandle([&OutArray](const HandleType& InElementHandle)
        {
            OutArray.Add(InElementHandle);
            return true;
        }, InBaseInterfaceType);
    }
 
    TYPEDELEMENTFRAMEWORK_API void ForEachElementHandle(TFunctionRef<bool(const HandleType&)> InCallback, const TSubclassOf<UInterface>& InBaseInterfaceType = {}) const;
 
    template <typename BaseInterfaceType>
    void ForEachElement(TFunctionRef<bool(const TTypedElement<BaseInterfaceType>&)> InCallback) const
    {
        TTypedElement<BaseInterfaceType> TempElement;
        for (const HandleType& ElementHandle : ElementHandles)
        {
            GetElement(ElementHandle, TempElement);
            if (TempElement && !InCallback(TempElement))
            {
                break;
            }
        }
    }
 
    inline bool IsValidIndex(const int32 InIndex) const
    {
        return ElementHandles.IsValidIndex(InIndex);
    }
 
    inline int32 Num() const
    {
        return ElementHandles.Num();
    }
 
    inline void Shrink()
    {
        ElementCombinedIds.Shrink();
        ElementHandles.Shrink();
    }
 
    inline void Reserve(const int32 InSize)
    {
        ElementCombinedIds.Reserve(InSize);
        ElementHandles.Reserve(InSize);
    }
 
    inline void Empty(const int32 InSlack = 0)
    {
        // Avoid creating unnecessary notifications
        const bool bWasEmpty = ElementHandles.IsEmpty();
        if (!bWasEmpty)
        {
            NoteListMayChange();
        }
 
        ElementCombinedIds.Empty(InSlack);
        ElementHandles.Empty(InSlack);
        ElementCounts.ClearCounters();
 
        if (!bWasEmpty)
        {
            ElementCounts.ClearCounters();
            NoteListChanged(EChangeType::Cleared);
        }
    }
 
    inline void Reset()
    {
        // Avoid creating unnecessary notifications
        if (!ElementHandles.IsEmpty())
        {
            NoteListMayChange();
            ElementCombinedIds.Reset();
            ElementHandles.Reset();
            ElementCounts.ClearCounters();
            NoteListChanged(EChangeType::Cleared);
        }
    }
 
    inline bool Contains(const FTypedElementId& InElementId) const
    {
        return ContainsElementImpl(InElementId);
    }
 
    inline bool Contains(const HandleType& InElementHandle) const
    {
        return ContainsElementImpl(InElementHandle.GetId());
    }
 
    template <typename ElementDataType>
    inline bool Contains(const TTypedElementOwner<ElementDataType>& InElementOwner)
    {
        return ContainsElementImpl(InElementOwner.GetId());
    }
 
    inline bool Add(const HandleType& InElementHandle)
    {
        return AddElementImpl(CopyTemp(InElementHandle));
    }
 
    inline bool Add(HandleType&& InElementHandle)
    {
        return AddElementImpl(MoveTemp(InElementHandle));
    }
 
    template <typename ElementDataType>
    inline bool Add(const TTypedElementOwner<ElementDataType>& InElementOwner)
    {
        return AddElementImpl(InElementOwner.AcquireHandle());
    }
 
    void Append(const TTypedElementListConstRef& InElementList)
    {
        if (this != &InElementList.Get())
        {
            FLegacySyncScopedBatch LegacySyncBatch(*this);
 
            Reserve(Num() + InElementList->Num());
            InElementList->ForEachElementHandle([this](const HandleType& ElementHandle)
            {
                AddElementImpl(CopyTemp(ElementHandle));
                return true;
            });
        }
    }
 
    void Append(TArrayView<const HandleType> InElementHandles)
    {
        FLegacySyncScopedBatch LegacySyncBatch(*this);
 
        Reserve(Num() + InElementHandles.Num());
        for (const HandleType& ElementHandle : InElementHandles)
        {
            AddElementImpl(CopyTemp(ElementHandle));
        }
    }
 
    template <typename ElementDataType>
    inline void Append(const TArray<TTypedElementOwner<ElementDataType>>& InElementOwners)
    {
        Append(MakeArrayView(InElementOwners));
    }
 
    template <typename ElementDataType>
    void Append(TArrayView<const TTypedElementOwner<ElementDataType>> InElementOwners)
    {
        FLegacySyncScopedBatch LegacySyncBatch(*this);
 
        Reserve(Num() + InElementOwners.Num());
        for (const TTypedElementOwner<ElementDataType>& ElementOwner : InElementOwners)
        {
            AddElementImpl(ElementOwner.AcquireHandle());
        }
    }
 
    inline bool Remove(const FTypedElementId& InElementId)
    {
        return RemoveElementImpl(InElementId);
    }
 
    inline bool Remove(const HandleType& InElementHandle)
    {
        return RemoveElementImpl(InElementHandle.GetId());
    }
 
    template <typename ElementDataType>
    inline bool Remove(const TTypedElementOwner<ElementDataType>& InElementOwner)
    {
        return RemoveElementImpl(InElementOwner.GetId());
    }
 
    inline int32 RemoveAll(TFunctionRef<bool(const HandleType&)> InPredicate)
    {
        return RemoveAllElementsImpl(InPredicate);
    }
 
    template <typename BaseInterfaceType>
    int32 RemoveAll(TFunctionRef<bool(const TTypedElement<BaseInterfaceType>&)> InPredicate)
    {
        TTypedElement<BaseInterfaceType> TempElement;
        return RemoveAllElementsImpl([this, &TempElement, &InPredicate](const HandleType& InElementHandle)
        {
            GetElement(InElementHandle, TempElement);
            return TempElement && InPredicate(TempElement);
        });
    }
 
    const FTypedElementCounter& GetCounter() const
    {
        return ElementCounts;
    }
 
    DECLARE_EVENT_OneParam(TTypedElementList, FOnPreChange, const TTypedElementList& /*InElementList*/);
    FOnPreChange& OnPreChange()
    {
        return OnPreChangeDelegate;
    }
 
    DECLARE_EVENT_OneParam(TTypedElementList, FOnChanged, const TTypedElementList& /*InElementList*/);
    FOnChanged& OnChanged()
    {
        return OnChangedDelegate;
    }
 
    TYPEDELEMENTFRAMEWORK_API bool NotifyPendingChanges();
 
    struct FScopedClearNewPendingChange
    {
        FScopedClearNewPendingChange() = default;
        TYPEDELEMENTFRAMEWORK_API FScopedClearNewPendingChange(TTypedElementList& InTypeElementList);
 
        FScopedClearNewPendingChange(const FScopedClearNewPendingChange&) = delete;
        FScopedClearNewPendingChange& operator=(const FScopedClearNewPendingChange&) = delete;
 
        TYPEDELEMENTFRAMEWORK_API FScopedClearNewPendingChange(FScopedClearNewPendingChange&& Other);
        TYPEDELEMENTFRAMEWORK_API FScopedClearNewPendingChange& operator=(FScopedClearNewPendingChange&& Other);
 
        TYPEDELEMENTFRAMEWORK_API ~FScopedClearNewPendingChange();
 
    private:
        TTypedElementList* TypedElementList = nullptr;
    };
 
    class FLegacySync
    {
    public:
        enum class ESyncType : uint8
        {
            Added,
 
            Removed,
 
            Modified,
 
            Cleared,
 
            BatchComplete,
        };
    
        TYPEDELEMENTFRAMEWORK_API FLegacySync(const TTypedElementList& InElementList);
 
        TYPEDELEMENTFRAMEWORK_API void Private_EmitSyncEvent(const ESyncType InSyncType, const HandleType& InElementHandle = HandleType());
 
        DECLARE_EVENT_FourParams(FLegacySync, FOnSyncEvent, const TTypedElementList& /*InElementList*/, ESyncType /*InSyncType*/, const HandleType& /*InElementHandle*/, bool /*bIsWithinBatchOperation*/);
        TYPEDELEMENTFRAMEWORK_API FOnSyncEvent& OnSyncEvent();
 
        TYPEDELEMENTFRAMEWORK_API bool IsRunningBatchOperation() const;
        TYPEDELEMENTFRAMEWORK_API void BeginBatchOperation();
        TYPEDELEMENTFRAMEWORK_API void EndBatchOperation(const bool InNotify = true);
        TYPEDELEMENTFRAMEWORK_API bool IsBatchOperationDirty() const;
        TYPEDELEMENTFRAMEWORK_API void ForceBatchOperationDirty();
 
    private:
        const TTypedElementList& ElementList;
 
        FOnSyncEvent OnSyncEventDelegate;
 
        int32 NumOpenBatchOperations = 0;
        bool bBatchOperationIsDirty = false;
    };
 
    class FLegacySyncScopedBatch
    {
    public:
        TYPEDELEMENTFRAMEWORK_API explicit FLegacySyncScopedBatch(const TTypedElementList& InElementList, const bool InNotify = true);
        TYPEDELEMENTFRAMEWORK_API ~FLegacySyncScopedBatch();
 
        FLegacySyncScopedBatch(const FLegacySyncScopedBatch&) = delete;
        FLegacySyncScopedBatch& operator=(const FLegacySyncScopedBatch&) = delete;
 
        FLegacySyncScopedBatch(FLegacySyncScopedBatch&&) = delete;
        FLegacySyncScopedBatch& operator=(FLegacySyncScopedBatch&&) = delete;
 
        TYPEDELEMENTFRAMEWORK_API bool IsDirty() const;
        TYPEDELEMENTFRAMEWORK_API void ForceDirty();
 
    private:
        FLegacySync* ElementListLegacySync = nullptr;
        bool bNotify = true;
    };
 
    TYPEDELEMENTFRAMEWORK_API FScopedClearNewPendingChange GetScopedClearNewPendingChange();
 
    TYPEDELEMENTFRAMEWORK_API FLegacySync& Legacy_GetSync();
 
    TYPEDELEMENTFRAMEWORK_API FLegacySync* Legacy_GetSyncPtr() const;
 
    static TYPEDELEMENTFRAMEWORK_API TTypedElementListRef Private_CreateElementList(UTypedElementRegistry* InRegistry);
 
    UTypedElementRegistry* GetRegistry() const
    {
        return Registry.Get();
    }
 
private:
    enum class EChangeType : uint8
    {
        Added,
 
        Removed,
 
        Cleared,
    };
 
    TYPEDELEMENTFRAMEWORK_API explicit TTypedElementList(UTypedElementRegistry* InRegistry);
 
    TYPEDELEMENTFRAMEWORK_API bool AddElementImpl(HandleType&& InElementHandle);
    TYPEDELEMENTFRAMEWORK_API bool RemoveElementImpl(const FTypedElementId& InElementId);
    TYPEDELEMENTFRAMEWORK_API int32 RemoveAllElementsImpl(TFunctionRef<bool(const HandleType&)> InPredicate);
    TYPEDELEMENTFRAMEWORK_API bool ContainsElementImpl(const FTypedElementId& InElementId) const;
 
    TYPEDELEMENTFRAMEWORK_API void NoteListMayChange();
    TYPEDELEMENTFRAMEWORK_API void NoteListChanged(const EChangeType InChangeType, const HandleType& InElementHandle = HandleType());
 
    TWeakObjectPtr<UTypedElementRegistry> Registry;
 
    TSet<FTypedHandleCombinedId> ElementCombinedIds;
 
    TArray<HandleType> ElementHandles;
 
    FTypedElementCounter ElementCounts;
 
    FOnPreChange OnPreChangeDelegate;
 
    FOnChanged OnChangedDelegate;
 
    bool bHasPendingNotify = false;
 
    TUniquePtr<FLegacySync> LegacySync;
};
 
 
namespace UE::TypedElementFramework
{
    TYPEDELEMENTFRAMEWORK_API FTypedElementListPtr ConvertToNativeTypedElementList(const FScriptTypedElementListConstPtr& ScriptList);
 
    TYPEDELEMENTFRAMEWORK_API FScriptTypedElementListPtr ConvertToScriptTypedElementList(const FTypedElementListConstPtr& NativeList);
 
}