TypedElementDataStorageInterface.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include <type_traits>
#include "Containers/Array.h"
#include "Containers/ContainersFwd.h"
#include "DataStorage/CommonTypes.h"
#include "DataStorage/Handles.h"
#include "DataStorage/MapKey.h"
#include "DataStorage/Queries/Description.h"
#include "DataStorage/Queries/Types.h"
#include "DataStorage/Queries/Conditions.h"
#include "Delegates/Delegate.h"
#include "Elements/Framework/TypedElementColumnUtils.h"
#include "Elements/Framework/TypedElementQueryCapabilities.h"
#include "Elements/Framework/TypedElementQueryFunctions.h"
#include "Elements/Interfaces/TypedElementQueryStorageInterfaces.h"
#include "Elements/Framework/TypedElementRowHandleArray.h"
#include "Elements/Framework/TypedElementRowHandleArrayView.h"
#include "Features/IModularFeature.h"
#include "Math/NumericLimits.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/Timespan.h"
#include "Templates/Function.h"
#include "UObject/Interface.h"
#include "UObject/NameTypes.h"
#include "UObject/ObjectMacros.h"
 
class UClass;
class USubsystem;
class UScriptStruct;
class UEditorDataStorageFactory;
 
namespace UE::Editor::DataStorage
{
using FTypedElementOnDataStorageCreation = FSimpleMulticastDelegate;
using FTypedElementOnDataStorageDestruction = FSimpleMulticastDelegate;
using FTypedElementOnDataStorageUpdate = FSimpleMulticastDelegate;
 
template<TColumnType... Columns>
struct TTypedElementColumnTypeList
{
    const UScriptStruct* ColumnTypes[sizeof...(Columns)] = { Columns::StaticStruct()... };
    
    operator TConstArrayView<const UScriptStruct*>() const { return ColumnTypes; }
};
 
struct FHierarchyRegistrationParams
{
    FName Name;
 
    // Optional column that is added to a row when the parent changes (useful for change detection).
    // This behaves similar to the sync tags and is removed at the end of the frame
    const UScriptStruct* ParentChangedColumn = nullptr;
};
    
class ICoreProvider : public IModularFeature
{
public:
    virtual const UEditorDataStorageFactory* FindFactory(const UClass* FactoryType) const = 0;
 
    virtual UEditorDataStorageFactory* FindFactory(const UClass* FactoryType) = 0;
 
    template<typename FactoryT>
    const FactoryT* FindFactory() const;
    
    template<typename FactoryT>
    FactoryT* FindFactory();
 
    virtual TableHandle RegisterTable(TConstArrayView<const UScriptStruct*> ColumnList, const FName& Name) = 0;
    template<TColumnType... Columns>
    TableHandle RegisterTable(const FName& Name);
    virtual TableHandle RegisterTable(TableHandle SourceTable,
        TConstArrayView<const UScriptStruct*> ColumnList, const FName& Name) = 0;
    template<TColumnType... Columns>
    TableHandle RegisterTable(TableHandle SourceTable, const FName& Name);
 
    virtual TableHandle FindTable(const FName& Name) = 0;
    
    virtual RowHandle ReserveRow() = 0;
    virtual void BatchReserveRows(int32 Count, TFunctionRef<void(RowHandle)> ReservationCallback) = 0;
    virtual void BatchReserveRows(TArrayView<RowHandle> ReservedRows) = 0;
 
    virtual RowHandle AddRow(TableHandle Table) = 0;
    virtual RowHandle AddRow(TableHandle Table,
        RowCreationCallbackRef OnCreated) = 0;
    virtual bool AddRow(RowHandle ReservedRow, TableHandle Table) = 0;
    virtual bool AddRow(RowHandle ReservedRow, TableHandle Table,
        RowCreationCallbackRef OnCreated) = 0;
 
    virtual bool BatchAddRow(TableHandle Table, int32 Count, RowCreationCallbackRef OnCreated) = 0;
    virtual bool BatchAddRow(TableHandle Table, TConstArrayView<RowHandle> ReservedHandles,
        RowCreationCallbackRef OnCreated) = 0;
 
    virtual void RemoveRow(RowHandle Row) = 0;
 
    virtual void BatchRemoveRows(TConstArrayView<RowHandle> Rows) = 0;
 
    virtual void RemoveAllRowsWithColumns(TConstArrayView<const UScriptStruct*> Columns) = 0;
 
    template<TColumnType... Columns>
    void RemoveAllRowsWith();
 
    virtual bool IsRowAvailable(RowHandle Row) const = 0;
    virtual bool IsRowAssigned(RowHandle Row) const = 0;
 
    enum class EFilterOptions : uint8
    {
        Inclusive,
        Exclusive
    };
 
    virtual void FilterRowsBy(
        FRowHandleArray& Result, FRowHandleArrayView Input, EFilterOptions Options, Queries::TQueryFunction<bool>& Filter) = 0;
    template<typename FilterFunction>
    void FilterRowsBy(FRowHandleArray& Result, FRowHandleArrayView Input, EFilterOptions Options, FilterFunction&& Filter);
 
    virtual void AddColumn(RowHandle Row, const UScriptStruct* ColumnType) = 0;
    template<TColumnType ColumnType>
    void AddColumn(RowHandle Row);
    virtual void AddColumnData(RowHandle Row, const UScriptStruct* ColumnType,
        const ColumnCreationCallbackRef Initializer,
        ColumnCopyOrMoveCallback Relocator) = 0;
    template<TDataColumnType ColumnType>
    void AddColumn(RowHandle Row, ColumnType&& Column);
 
    virtual void AddColumn(RowHandle Row, const FValueTag& Tag, const FName& Value) = 0;
 
    template<typename T>
    void AddColumn(RowHandle Row, const FName& Tag) = delete;
    
    template<typename T>
    void AddColumn(RowHandle Row, const FName& Tag, const FName& Value) = delete;
    
    template<>
    void AddColumn<FValueTag>(RowHandle Row, const FName& Tag, const FName& Value);
 
    template<TEnumType EnumT>
    void AddColumn(RowHandle Row, EnumT Value);
    
    template<auto Value, TEnumType EnumT = decltype(Value)>
    void AddColumn(RowHandle Row);
 
    template<TDynamicColumnTemplate DynamicColumnTemplate>
    void AddColumn(RowHandle Row, const FName& Identifier);
    
    template<TDynamicColumnTemplate DynamicColumnTemplate>
    void AddColumn(RowHandle Row, const FName& Identifier, DynamicColumnTemplate&& TemplateInstance);
 
    virtual void AddColumns(RowHandle Row, TConstArrayView<const UScriptStruct*> Columns) = 0;
    template<TColumnType... Columns>
    void AddColumns(RowHandle Row);
 
    virtual void RemoveColumn(RowHandle Row, const UScriptStruct* ColumnType) = 0;
    template<TColumnType Column>
    void RemoveColumn(RowHandle Row);
 
    template<TEnumType EnumT>
    void RemoveColumn(RowHandle Row);
 
    virtual void RemoveColumn(RowHandle Row, const FValueTag& Tag) = 0;
 
    template<typename T>
    void RemoveColumn(RowHandle Row, const FName& Tag) = delete;
 
    template<TDynamicColumnTemplate DynamicColumnTemplateType>
    void RemoveColumn(RowHandle Row, const FName& Identifier);
    
    template<>
    void RemoveColumn<FValueTag>(RowHandle Row, const FName& Tag);
 
    virtual void RemoveColumns(RowHandle Row, TConstArrayView<const UScriptStruct*> Columns) = 0;
    template<TColumnType... Columns>
    void RemoveColumns(RowHandle Row);
 
    virtual void AddRemoveColumns(RowHandle Row, TConstArrayView<const UScriptStruct*> ColumnsToAdd,
        TConstArrayView<const UScriptStruct*> ColumnsToRemove) = 0;
    
    virtual void BatchAddRemoveColumns(
        TConstArrayView<RowHandle> Rows,
        TConstArrayView<const UScriptStruct*> ColumnsToAdd,
        TConstArrayView<const UScriptStruct*> ColumnsToRemove) = 0;
    
    virtual void* GetColumnData(RowHandle Row, const UScriptStruct* ColumnType) = 0;
    virtual const void* GetColumnData(RowHandle Row, const UScriptStruct* ColumnType) const = 0;
    template<TDataColumnType ColumnType>
    ColumnType* GetColumn(RowHandle Row);
    template<TDataColumnType ColumnType>
    const ColumnType* GetColumn(RowHandle Row) const;
    // Gets a dynamic column identified by the ColumnTypeTemplate and Identifier
    template<TDynamicColumnTemplate ColumnTypeTemplate>
    ColumnTypeTemplate* GetColumn(RowHandle Row, const FName& Identifer);
    template<TDynamicColumnTemplate ColumnTypeTemplate>
    const ColumnTypeTemplate* GetColumn(RowHandle Row, const FName& Identifer) const;
    
    virtual bool HasColumns(RowHandle Row, TConstArrayView<const UScriptStruct*> ColumnTypes) const = 0;
    virtual bool HasColumns(RowHandle Row, TConstArrayView<TWeakObjectPtr<const UScriptStruct>> ColumnTypes) const = 0;
    template<TColumnType... ColumnTypes>
    bool HasColumns(RowHandle Row) const;
 
    virtual void ListColumns(RowHandle Row, ColumnListCallbackRef Callback) const = 0;
 
    virtual void ListColumns(RowHandle Row, ColumnListWithDataCallbackRef Callback) = 0;
 
    virtual bool MatchesColumns(RowHandle Row, const Queries::FConditions& Conditions) const = 0;
 
    virtual const UScriptStruct* FindDynamicColumn(const FDynamicColumnDescription& Description) const = 0;
 
    virtual const UScriptStruct* GenerateDynamicColumn(const FDynamicColumnDescription& Description) = 0;
 
    virtual void ForEachDynamicColumn(const UScriptStruct& Template, TFunctionRef<void(const UScriptStruct& Type)> Callback) const = 0;
 
    template<TDynamicColumnTemplate DynamicColumnTemplateType>
    void ForEachDynamicColumn(TFunctionRef<void(const UScriptStruct& Type)> Callback) const;
 
    // Hierarchy Interface
    //-----------------------
    
    virtual UE::Editor::DataStorage::FHierarchyHandle RegisterHierarchy(const UE::Editor::DataStorage::FHierarchyRegistrationParams& Params) = 0;
    virtual UE::Editor::DataStorage::FHierarchyHandle FindHierarchyByName(const FName& Name) const = 0;
    virtual bool IsValidHierachyHandle(FHierarchyHandle) const = 0;
 
    // Gets the tag type indicating the row is a child in this hierarchy and thus has a parent
    virtual const UScriptStruct* GetChildTagType(FHierarchyHandle InHierarchyHandle) const = 0;
    // Gets the tag type indicating the row is a parent in this hierarchy and thus has a child
    virtual const UScriptStruct* GetParentTagType(FHierarchyHandle InHierarchyHandle) const = 0;
    // Gets the column type storing the hierarchy data. Note that the format of this type is opaque
    // and is used internally.  It is the caller's responsibility to provide at least Read access
    // to this column type in query requirements in order to use the HierarchyAccessInterface on the row
    virtual const UScriptStruct* GetHierarchyDataColumnType(FHierarchyHandle InHierarchyHandle) const = 0;
    // List all the currently known hierarchies by name
    virtual void ListHierarchyNames(TFunctionRef<void(const FName& HierarchyName)> Callback) const = 0;
 
    // CoreProvider Context API
    // =========================
 
    // Establishes a parent relationship between the Target and the Parent
    virtual void SetParentRow(
        FHierarchyHandle InHierarchyHandle,
        RowHandle Target,
        RowHandle Parent) = 0;
 
    virtual void SetUnresolvedParent(
        FHierarchyHandle InHierarchyHandle,
        RowHandle Target,
        FMapKey ParentId,
        FName MappingDomain) = 0;
 
    // Gets the parent of a target, if there is one
    virtual RowHandle GetParentRow(FHierarchyHandle InHierarchyHandle, RowHandle Target) const = 0;
    
    // Returns a callable which will extract the parent row from the hierarchy's HierarchyDataColumn
    // Note that the second parameter must be the same as what is returned by GetHierarchyDataColumn()
    // and the first parameter should point to a struct of that type
    virtual TFunction<RowHandle(const void*, const UScriptStruct*)> CreateParentExtractionFunction(FHierarchyHandle InHierarchyHandle) const = 0; 
    
    virtual bool HasChildren(FHierarchyHandle InHierarchyHandle, RowHandle Row) const = 0;
 
    // Iterates depth first from the passed in Row, calling the VisitFn on each row
    // The Row passed in will have VisitFn called on it
    virtual void WalkDepthFirst(
        FHierarchyHandle InHierarchyHandle,
        RowHandle Row,
        TFunction<void(const ICoreProvider& Context, RowHandle Owner, RowHandle Target)> VisitFn) const = 0;
    
    virtual void DebugPrintQueryCallbacks(FOutputDevice& Output) = 0;
    
    virtual QueryHandle RegisterQuery(FQueryDescription&& Query) = 0;
    virtual void UnregisterQuery(QueryHandle Query) = 0;
    virtual const FQueryDescription& GetQueryDescription(QueryHandle Query) const = 0;
    virtual FName GetQueryTickGroupName(EQueryTickGroups Group) const = 0;
    virtual FQueryResult RunQuery(QueryHandle Query) = 0;
    virtual FQueryResult RunQuery(QueryHandle Query, DirectQueryCallbackRef Callback) = 0;
    virtual FQueryResult RunQuery(QueryHandle Query, EDirectQueryExecutionFlags Flags, DirectQueryCallbackRef Callback) = 0;
    virtual FQueryResult RunQuery(QueryHandle Query, ERunQueryFlags Flags, const Queries::TQueryFunction<void>& Callback) = 0;
    template<Queries::FunctionType Function>
    FQueryResult RunQuery(QueryHandle Query, ERunQueryFlags Flags, Function&& Callback);
    template<typename ResultType, Queries::FunctionType Function>
    FQueryResult RunQuery(QueryHandle Query, ERunQueryFlags Flags, Queries::TResult<ResultType>& Result, Function&& Callback);
    
    virtual void ActivateQueries(FName ActivationName) = 0;
 
    virtual RowHandle LookupMappedRow(const FName& Domain, const FMapKeyView& Key) const = 0;
    virtual void MapRow(const FName& Domain, FMapKey Key, RowHandle Row) = 0;
    virtual void BatchMapRows(const FName& Domain, TArrayView<TPair<FMapKey, RowHandle>> MapRowPairs) = 0;
    virtual void RemapRow(const FName& Domain, const FMapKeyView& OriginalKey, FMapKey NewKey) = 0;
    virtual void RemoveRowMapping(const FName& Domain, const FMapKeyView& Key) = 0;
    
    virtual FTypedElementOnDataStorageUpdate& OnUpdate() = 0;
    virtual FTypedElementOnDataStorageUpdate& OnUpdateCompleted() = 0;
 
    using FOnCooperativeUpdate = TFunction<void(FTimespan TimeAllowance)>;
    enum class ECooperativeTaskPriority : uint8
    {
        High,
        Medium,
        Low
    };
    virtual void RegisterCooperativeUpdate(const FName& TaskName, ECooperativeTaskPriority Priority, FOnCooperativeUpdate Callback) = 0;
    virtual void UnregisterCooperativeUpdate(const FName& TaskName) = 0;
 
    virtual bool IsAvailable() const = 0;
 
    virtual void* GetExternalSystemAddress(UClass* Target) = 0;
    template<typename SystemType>
    SystemType* GetExternalSystem();
 
    virtual bool SupportsExtension(FName Extension) const = 0;
    virtual void ListExtensions(TFunctionRef<void(FName)> Callback) const = 0;
 
 
    UE_DEPRECATED(5.6, "Use 'LookUpMappedRow' instead and use the new FMapKey(View) instead of the explicit 'GenerateIndexHash'-functions.")
    inline RowHandle FindIndexedRow(IndexHash Index) const;
    UE_DEPRECATED(5.6, "Use 'MapRow' instead and use the new FMapKey(View) instead of the explicit 'GenerateIndexHash'-functions.")
    inline void IndexRow(IndexHash Index, RowHandle Row);
    UE_DEPRECATED(5.6, "Use 'BatchMapRows' instead and use the new FMapKey(View) instead of the explicit 'GenerateIndexHash'-functions.")
    inline void BatchIndexRows(TConstArrayView<TPair<IndexHash, RowHandle>> IndexRowPairs);
    UE_DEPRECATED(5.6, "Use 'RemapRow' instead and use the new FMapKey(View) instead of the explicit 'GenerateIndexHash'-functions.")
    inline void Reindex(IndexHash OriginalIndex, IndexHash NewIndex);
    UE_DEPRECATED(5.6, "Use 'RemovedRowMapping' instead and use the new FMapKey(View) instead of the explicit 'GenerateIndexHash'-functions.")
    inline void RemoveIndex(IndexHash Index);
    UE_DEPRECATED(5.6, "Use 'RemapRow' instead and use the new FMapKey(View) instead of the explicit 'GenerateIndexHash'-functions. The Row argument is no longer used.")
    inline void ReindexRow(IndexHash OriginalIndex, IndexHash NewIndex, RowHandle Row);
 
    UE_DEPRECATED(5.7, "Use the version of 'LookupMappedRow' that uses a domain.")
    inline RowHandle LookupMappedRow(const FMapKeyView& Key) const;
    UE_DEPRECATED(5.7, "Use the version of 'MapRow' that uses a domain.")
    inline void MapRow(FMapKey Key, RowHandle Row);
    UE_DEPRECATED(5.7, "Use the version of 'BatchMapRows' that uses a domain.")
    inline void BatchMapRows(TArrayView<TPair<FMapKey, RowHandle>> MapRowPairs);
    UE_DEPRECATED(5.7, "Use the version of 'RemapRow' that uses a domain.")
    inline void RemapRow(const FMapKeyView& OriginalKey, FMapKey NewKey);
    UE_DEPRECATED(5.7, "Use the version of 'RemoveRowMapping' that uses a domain.")
    inline void RemoveRowMapping(const FMapKeyView& Key);
};
 
// Implementations
 
template <typename FactoryT>
const FactoryT* ICoreProvider::FindFactory() const
{
    return static_cast<const FactoryT*>(FindFactory(FactoryT::StaticClass()));
}
 
template <typename FactoryT>
FactoryT* ICoreProvider::FindFactory()
{
    return static_cast<FactoryT*>(FindFactory(FactoryT::StaticClass()));
}
 
template<TColumnType... Columns>
TableHandle ICoreProvider::RegisterTable(const FName& Name)
{
    return RegisterTable({ Columns::StaticStruct()... }, Name);
}
 
template<TColumnType... Columns>
TableHandle ICoreProvider::RegisterTable(
    TableHandle SourceTable, const FName& Name)
{
    return RegisterTable(SourceTable, { Columns::StaticStruct()... }, Name);
}
 
template<typename FilterFunction>
void ICoreProvider::FilterRowsBy(FRowHandleArray& Result, FRowHandleArrayView Input, EFilterOptions Options, FilterFunction&& Filter)
{
    FilterRowsBy(Result, Input, Options, Queries::BuildQueryFunction<bool>(Forward<FilterFunction>(Filter)));
}
 
template<TColumnType Column>
void ICoreProvider::AddColumn(RowHandle Row)
{
    AddColumn(Row, Column::StaticStruct());
}
 
template<TColumnType Column>
void ICoreProvider::RemoveColumn(RowHandle Row)
{
    RemoveColumn(Row, Column::StaticStruct());
}
 
template<TColumnType... Columns>
void ICoreProvider::AddColumns(RowHandle Row)
{
    AddColumns(Row, { Columns::StaticStruct()...});
}
 
template <>
inline void ICoreProvider::AddColumn<FValueTag>(RowHandle Row, const FName& Tag, const FName& Value)
{
    AddColumn(Row, FValueTag(Tag), Value);
}
 
template <>
inline void ICoreProvider::RemoveColumn<FValueTag>(RowHandle Row, const FName& Tag)
{
    using namespace UE::Editor::DataStorage;
    RemoveColumn(Row, FValueTag(Tag));
}
 
template<TDynamicColumnTemplate DynamicColumnTemplate>
void ICoreProvider::RemoveColumn(RowHandle Row, const FName& Identifier)
{
    const FDynamicColumnDescription Description
    {
        .TemplateType = DynamicColumnTemplate::StaticStruct(),
        .Identifier = Identifier
    };
    const UScriptStruct* StructInfo = FindDynamicColumn(Description);
    RemoveColumn(Row, StructInfo);
}
 
template<TEnumType EnumT>
void ICoreProvider::AddColumn(RowHandle Row, EnumT Value)
{
    const UEnum* Enum = StaticEnum<EnumT>();
    const FName ValueAsFName = *Enum->GetNameStringByValue(static_cast<int64>(Value));
    if (ValueAsFName != NAME_None)
    {
        AddColumn(Row, FValueTag(Enum->GetFName()), ValueAsFName);
    }
}
 
template<TColumnType... Columns>
void ICoreProvider::RemoveAllRowsWith()
{
    RemoveAllRowsWithColumns({ Columns::StaticStruct()... });
}
 
template<auto Value, TEnumType EnumT>
void ICoreProvider::AddColumn(RowHandle Row)
{
    AddColumn<EnumT>(Row, Value);
}
 
template <TDynamicColumnTemplate DynamicColumnTemplate>
void ICoreProvider::AddColumn(RowHandle Row, const FName& Identifier)
{
    const FDynamicColumnDescription Description
    {
        .TemplateType = DynamicColumnTemplate::StaticStruct(),
        .Identifier = Identifier
    };
    const UScriptStruct* StructInfo = GenerateDynamicColumn(Description);
    AddColumn(Row, StructInfo);
}
 
template <TDynamicColumnTemplate DynamicColumnTemplate>
void ICoreProvider::AddColumn(RowHandle Row, const FName& Identifier, DynamicColumnTemplate&& TemplateInstance)
{
    const FDynamicColumnDescription Description
    {
        .TemplateType = DynamicColumnTemplate::StaticStruct(),
        .Identifier = Identifier
    };
    const UScriptStruct* StructInfo = GenerateDynamicColumn(Description);
    AddColumnData(Row, StructInfo,
        [&TemplateInstance](void* ColumnData, const UScriptStruct&)
        {
            if constexpr (std::is_move_constructible_v<DynamicColumnTemplate>)
            {
                new(ColumnData) DynamicColumnTemplate(MoveTemp(TemplateInstance));
            }
            else
            {
                new(ColumnData) DynamicColumnTemplate(TemplateInstance);
            }
        },
        [](const UScriptStruct&, void* Destination, void* Source)
        {
            if constexpr (std::is_move_assignable_v<DynamicColumnTemplate>)
            {
                *static_cast<DynamicColumnTemplate*>(Destination) = MoveTemp(*static_cast<DynamicColumnTemplate*>(Source));
            }
            else
            {
                *static_cast<DynamicColumnTemplate*>(Destination) = *static_cast<DynamicColumnTemplate*>(Source);
            }
        });
    
}
 
template<TEnumType EnumT>
void ICoreProvider::RemoveColumn(RowHandle Row)
{
    const UEnum* Enum = StaticEnum<EnumT>();
    RemoveColumn(Row, FValueTag(Enum->GetFName()));
}
 
template<TColumnType... Columns>
void ICoreProvider::RemoveColumns(RowHandle Row)
{
    RemoveColumns(Row, { Columns::StaticStruct()...});
}
 
template<TDataColumnType ColumnType>
void ICoreProvider::AddColumn(RowHandle Row, ColumnType&& Column)
{
    AddColumnData(Row, ColumnType::StaticStruct(),
        [&Column](void* ColumnData, const UScriptStruct&)
        {
            if constexpr (std::is_move_constructible_v<ColumnType>)
            {
                new(ColumnData) ColumnType(MoveTemp(Column));
            }
            else
            {
                new(ColumnData) ColumnType(Column);
            }
        },
        [](const UScriptStruct&, void* Destination, void* Source)
        {
            if constexpr (std::is_move_assignable_v<ColumnType>)
            {
                *reinterpret_cast<ColumnType*>(Destination) = MoveTemp(*reinterpret_cast<ColumnType*>(Source));
            }
            else
            {
                *reinterpret_cast<ColumnType*>(Destination) = *reinterpret_cast<ColumnType*>(Source);
            }
        });
}
 
template<TDataColumnType ColumnType>
ColumnType* ICoreProvider::GetColumn(RowHandle Row)
{
    return reinterpret_cast<ColumnType*>(GetColumnData(Row, ColumnType::StaticStruct()));
}
 
template<TDataColumnType ColumnType>
const ColumnType* ICoreProvider::GetColumn(RowHandle Row) const
{
    return reinterpret_cast<const ColumnType*>(GetColumnData(Row, ColumnType::StaticStruct()));
}
 
template <TDynamicColumnTemplate DynamicColumnTemplate>
DynamicColumnTemplate* ICoreProvider::GetColumn(RowHandle Row, const FName& Identifier)
{
    const FDynamicColumnDescription Description
    {
        .TemplateType = DynamicColumnTemplate::StaticStruct(),
        .Identifier = Identifier
    };
    const UScriptStruct* StructInfo = GenerateDynamicColumn(Description);
    if (StructInfo)
    {
        return static_cast<DynamicColumnTemplate*>(GetColumnData(Row, StructInfo));
    }
    return nullptr;
}
 
template <TDynamicColumnTemplate DynamicColumnTemplate>
const DynamicColumnTemplate* ICoreProvider::GetColumn(RowHandle Row, const FName& Identifier) const
{
    const FDynamicColumnDescription Description
    {
        .TemplateType = DynamicColumnTemplate::StaticStruct(),
        .Identifier = Identifier
    };
    const UScriptStruct* StructInfo = FindDynamicColumn(Description);
    if (StructInfo)
    {
        return static_cast<const DynamicColumnTemplate*>(GetColumnData(Row, StructInfo));
    }
    return nullptr;
}
 
template<TColumnType... ColumnType>
bool ICoreProvider::HasColumns(RowHandle Row) const
{
    return HasColumns(Row, TConstArrayView<const UScriptStruct*>({ ColumnType::StaticStruct()... }));
}
 
template<typename SystemType>
SystemType* ICoreProvider::GetExternalSystem()
{
    return reinterpret_cast<SystemType*>(GetExternalSystemAddress(SystemType::StaticClass()));
}
 
void ICoreProvider::ReindexRow(
    IndexHash OriginalIndex, IndexHash NewIndex, RowHandle Row)
{
    RemapRow(NAME_None, FMapKeyView(OriginalIndex), FMapKey(NewIndex));
}
 
RowHandle ICoreProvider::FindIndexedRow(IndexHash Index) const
{
    return LookupMappedRow(NAME_None, FMapKeyView(Index));
}
 
void ICoreProvider::IndexRow(IndexHash Index, RowHandle Row)
{
    MapRow(NAME_None, FMapKey(Index), Row);
}
 
void ICoreProvider::BatchIndexRows(TConstArrayView<TPair<IndexHash, RowHandle>> IndexRowPairs)
{
    for (const TPair<IndexHash, RowHandle>& Pair : IndexRowPairs)
    {
        MapRow(NAME_None, FMapKey(Pair.Key), Pair.Value);
    }
}
 
void ICoreProvider::Reindex(IndexHash OriginalIndex, IndexHash NewIndex)
{
    RemapRow(NAME_None, FMapKeyView(OriginalIndex), FMapKey(NewIndex));
}
 
void ICoreProvider::RemoveIndex(IndexHash Index)
{
    RemoveRowMapping(NAME_None, FMapKeyView(Index));
}
 
RowHandle ICoreProvider::LookupMappedRow(const FMapKeyView& Key) const
{
    return LookupMappedRow(NAME_None, Key);
}
 
void ICoreProvider::MapRow(FMapKey Key, RowHandle Row)
{
    MapRow(NAME_None, Key, Row);
}
 
void ICoreProvider::BatchMapRows(TArrayView<TPair<FMapKey, RowHandle>> MapRowPairs)
{
    BatchMapRows(NAME_None, MapRowPairs);
}
 
void ICoreProvider::RemapRow(const FMapKeyView& OriginalKey, FMapKey NewKey)
{
    RemapRow(NAME_None, OriginalKey, NewKey);
}
 
void ICoreProvider::RemoveRowMapping(const FMapKeyView& Key)
{
    RemoveRowMapping(NAME_None, Key);
}
 
template<TDynamicColumnTemplate DynamicColumnTemplateType>
void ICoreProvider::ForEachDynamicColumn(TFunctionRef<void(const UScriptStruct& Type)> Callback) const
{
    ForEachDynamicColumn(DynamicColumnTemplateType::StaticStruct(), Callback);
}
 
template<Queries::FunctionType Function>
FQueryResult ICoreProvider::RunQuery(QueryHandle Query, ERunQueryFlags Flags, Function&& Callback)
{
    return RunQuery(Query, Flags, Queries::BuildQueryFunction<void>(Forward<Function>(Callback)));
}
 
template<typename ResultType, Queries::FunctionType Function>
FQueryResult ICoreProvider::RunQuery(QueryHandle Query, ERunQueryFlags Flags, Queries::TResult<ResultType>& Result, Function&& Callback)
{
    return RunQuery(Query, Flags, Queries::BuildQueryFunction(Result, Forward<Function>(Callback)));
}
 
} // namespace UE::Editor::DataStorage