TypedElementQueryStorageInterfaces.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/ContainersFwd.h"
#include "DataStorage/CommonTypes.h"
#include "DataStorage/Handles.h"
#include "DataStorage/MapKey.h"
#include "DataStorage/Queries/Types.h"
#include "UObject/Class.h"
#include "UObject/WeakObjectPtrTemplates.h"
#include "Templates/Function.h"
 
class UClass;
class UObject;
class UScriptStruct;
 
namespace UE::Editor::DataStorage
{
    struct FQueryDescription;
    struct ISubqueryContext;
 
    using SubqueryCallback = TFunction<void(const FQueryDescription&, ISubqueryContext&)>;
    using SubqueryCallbackRef = TFunctionRef<void(const FQueryDescription&, ISubqueryContext&)>;
    
    struct ICommonQueryContext
    {
        virtual ~ICommonQueryContext() = default;
 
        virtual uint32 GetRowCount() const = 0;
        virtual TConstArrayView<RowHandle> GetRowHandles() const = 0;
 
        virtual const void* GetColumn(const UScriptStruct* ColumnType) const = 0;
        template<TDataColumnType Column>
        const Column* GetColumn() const;
        template<TDynamicColumnTemplate TemplateType>
        const TemplateType* GetColumn(const FName& Identifier) const;
        virtual void* GetMutableColumn(const UScriptStruct* ColumnType) = 0;
        template<typename Column>
        Column* GetMutableColumn();
        template<TDynamicColumnTemplate TemplateType>
        TemplateType* GetMutableColumn(const FName& Identifier);
 
        virtual void GetColumns(TArrayView<char*> RetrievedAddresses, TConstArrayView<TWeakObjectPtr<const UScriptStruct>> ColumnTypes,
            TConstArrayView<EQueryAccessType> AccessTypes) = 0;
        virtual void GetColumnsUnguarded(int32 TypeCount, char** RetrievedAddresses, const TWeakObjectPtr<const UScriptStruct>* ColumnTypes,
            const EQueryAccessType* AccessTypes) = 0;
        /* 
         * Returns whether a column matches the requested type or not. This version only applies to the table that's currently set in
         * the context. This version is faster of checking in the current row or table, but the version using a row is needed to check
         * arbitrary rows.
         */
        virtual bool HasColumn(const UScriptStruct* ColumnType) const = 0;
        /*
         * Returns whether a column matches the requested type or not. This version only applies to the table that's currently set in
         * the context. This version is faster of checking in the current row or table, but the version using a row is needed to check
         * arbitrary rows.
         */
        template<typename Column>
        bool HasColumn() const;
        /*
         * Return whether a column matches the requested type or not. This can be used for arbitrary rows. If the row is in the
         * table that's set in the context, for instance because it's the current row, then the version that doesn't take a row
         * as an argument is recommended.
         */
        virtual bool HasColumn(RowHandle Row, const UScriptStruct* ColumnType) const = 0;
        /*
         * Return whether a column matches the requested type or not. This can be used for arbitrary rows. If the row is in the
         * table that's set in the context, for instance because it's the current row, then the version that doesn't take a row
         * as an argument is recommended.
         */
        template<typename Column>
        bool HasColumn(RowHandle Row) const;
 
        template<TDynamicColumnTemplate DynamicColumnTemplate>
        bool HasColumn(RowHandle Row, const FName& Identifier) const;
 
        virtual const UScriptStruct* FindDynamicColumnType(const FDynamicColumnDescription& Description) const = 0;
        template<TDynamicColumnTemplate TemplateType>
        const UScriptStruct* FindDynamicColumnType(const FName& Identifier) const;
 
        // Sets the Target's Parent if the query has a configured Hierarchy
        virtual void SetParentRow(
            RowHandle Target,
            RowHandle Parent) = 0;
 
        virtual void SetUnresolvedParent(
            RowHandle Target,
            FMapKey ParentId,
            FName MappingDomain) = 0;
 
        // Gets the Target's Parent if the query has a configured Hierarchy
        virtual RowHandle GetParentRow(
            RowHandle Target) const = 0;
 
        virtual float GetDeltaTimeSeconds() const = 0;
 
        template<typename T>
        void PushCommand(T CommandContext);
        
        virtual void PushCommand(void (*CommandFunction)(void* /*CommandData*/), void* InCommandData) = 0;
    protected:
        struct FEmplaceObjectParams
        {
            size_t ObjectSize;
            size_t Alignment;
            void (*Construct)(void*, void*);
            void(*Destroy)(void*);
            void* SourceObject;
        };
        // Required as the interface doesn't have direct access to any temporary handling of memory in the backend.
        virtual void* EmplaceObjectInScratch(const FEmplaceObjectParams& Params) = 0;
    };
 
    struct ICommonQueryWithEnvironmentContext : public ICommonQueryContext
    {
        using ObjectCopyOrMove = void (*)(const UScriptStruct& TypeInfo, void* Destination, void* Source);
 
        using ICommonQueryContext::GetColumn;
        using ICommonQueryContext::HasColumn;
        using ICommonQueryContext::GetMutableColumn;
        
        template<typename DynamicColumnTemplate>
        const DynamicColumnTemplate* GetColumn(const FName& Identifier) const;
 
        template<typename DynamicColumnTemplate>
        DynamicColumnTemplate* GetMutableColumn(const FName& Identifier);
 
        /*
         * Helper template to return whether a row has a given dynamic column.
         */
        template<typename DynamicColumnTemplate>
        bool HasColumn(const FName& Identifier) const;
        
        /*
         * Helper template to return whether a row has a given dynamic column.
         */
        template<typename DynamicColumnTemplate>
        bool HasColumn(RowHandle Row, const FName& Identifier) const;
 
        virtual uint64 GetUpdateCycleId() const = 0;
        
        virtual bool IsRowAvailable(RowHandle Row) const = 0;
        virtual bool IsRowAssigned(RowHandle Row) const = 0;
 
        virtual void ActivateQueries(FName ActivationName) = 0;
 
        virtual RowHandle AddRow(TableHandle Table) = 0;
        
        virtual void RemoveRow(RowHandle Row) = 0;
        virtual void RemoveRows(TConstArrayView<RowHandle> Rows) = 0;
 
        template<typename ColumnType>
        ColumnType& AddColumn(RowHandle Row, ColumnType&& Column);
        template<typename ColumnTypeTemplate>
        ColumnTypeTemplate* AddColumn(RowHandle Row, const FName& Identifier);
        template<typename ColumnTypeTemplate>
        ColumnTypeTemplate& AddColumn(RowHandle Row, const FName& Identifier, ColumnTypeTemplate&& Column);
        template<typename... Columns>
        void AddColumns(RowHandle Row);
        template<typename... Columns>
        void AddColumns(TConstArrayView<RowHandle> Rows);
        virtual void AddColumns(RowHandle Row, TConstArrayView<const UScriptStruct*> ColumnTypes) = 0;
        virtual void AddColumns(TConstArrayView<RowHandle> Rows, TConstArrayView<const UScriptStruct*> ColumnTypes) = 0;
        
        virtual void AddColumns(TConstArrayView<RowHandle> Rows, TConstArrayView<FDynamicColumnDescription> DynamicColumnDescriptions) = 0;
        virtual void* AddColumnUninitialized(RowHandle Row, const UScriptStruct* ColumnType) = 0;
        virtual void* AddColumnUninitialized(RowHandle Row, const UScriptStruct* ObjectType, ObjectCopyOrMove Relocator) = 0;
 
        virtual void* AddColumnUninitialized(RowHandle Row, const FDynamicColumnDescription& DynamicColumnDescription, ObjectCopyOrMove Relocator) = 0;
        virtual void* AddColumnUninitialized(RowHandle Row, const FDynamicColumnDescription& DynamicColumnDescription) = 0;
        
 
        template<typename... Columns>
        void RemoveColumns(RowHandle Row);
        template<typename... Columns>
        void RemoveColumns(TConstArrayView<RowHandle> Rows);
        virtual void RemoveColumns(RowHandle Row, TConstArrayView<const UScriptStruct*> ColumnTypes) = 0;
        virtual void RemoveColumns(TConstArrayView<RowHandle> Rows, TConstArrayView<const UScriptStruct*> ColumnTypes) = 0;
    };
 
    enum class EDirectQueryExecutionFlags : uint32
    {
        Default = 0, //< No settings, use the default behavior.
        ParallelizeChunks = 1 << 0, //< If set, each chunk is processed on a separate thread.
        /*
         * Requires ParallelizeChunks to be set.
         * If set together with ParallelizeChunks, each chunk will be scheduled individually. This allows work to be better
         * distributed among threads, but comes at additional scheduling cost. Add this flag if the processing time per chunk varies.
         */
        AutoBalanceParallelChunkProcessing = 1 << 1,
        IgnoreActiveState = 1 << 2, //< If set, a direct call will not check activatable queries if they're set.
        AllowBoundQueries = 1 << 3, //< Stops checking if queries are bound when set, otherwise bound queries will assert.
 
        IgnoreActivationCount UE_DEPRECATED("5.7", "Activation counts are no longer supported.") = IgnoreActiveState,
    };
    ENUM_CLASS_FLAGS(EDirectQueryExecutionFlags);
 
    // For now this is an exact mirror of EDirectQueryExecutionFlags (except deprecated flags) in order to separate the old and the new 
    // query callbacks/context. Please keep both in sync until the old query callbacks/context has been fully deprecated.
    enum class ERunQueryFlags : uint32
    {
        Default = 0, //< No settings, use the default behavior.
        ParallelizeChunks = 1 << 0, //< If set, each chunk is processed on a separate thread.
        /*
         * Requires ParallelizeChunks to be set.
         * If set together with ParallelizeChunks, each chunk will be scheduled individually. This allows work to be better
         * distributed among threads, but comes at additional scheduling cost. Add this flag if the processing time per chunk varies.
         */
        AutoBalanceParallelChunkProcessing = 1 << 1,
        IgnoreActiveState = 1 << 2, //< If set, a direct call will not check activatable queries if they're set.
        AllowBoundQueries = 1 << 3, //< Stops checking if queries are bound when set, otherwise bound queries will assert.
    };
    ENUM_CLASS_FLAGS(ERunQueryFlags);
 
    struct IDirectQueryContext : public ICommonQueryContext
    {
        virtual ~IDirectQueryContext() = default;
    };
 
    struct ISubqueryContext : public ICommonQueryWithEnvironmentContext
    {
        virtual ~ISubqueryContext() = default;
    };
 
    struct IQueryContext : public ICommonQueryWithEnvironmentContext
    {
        virtual ~IQueryContext() = default;
 
        virtual const UObject* GetDependency(const UClass* DependencyClass) = 0;
        virtual UObject* GetMutableDependency(const UClass* DependencyClass) = 0;
        
        virtual void GetDependencies(TArrayView<UObject*> RetrievedAddresses, TConstArrayView<TWeakObjectPtr<const UClass>> DependencyTypes,
            TConstArrayView<EQueryAccessType> AccessTypes) = 0;
 
        virtual RowHandle LookupMappedRow(const FName& Domain, const FMapKeyView& Index) const = 0;
 
        virtual FQueryResult RunQuery(QueryHandle Query) = 0;
        virtual FQueryResult RunSubquery(int32 SubqueryIndex) = 0;
        virtual FQueryResult RunSubquery(int32 SubqueryIndex, SubqueryCallbackRef Callback) = 0;
        virtual FQueryResult RunSubquery(int32 SubqueryIndex, RowHandle Row, SubqueryCallbackRef Callback) = 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.7, "Use the version of this 'LookupMappedRow' that uses a domain.")
        inline RowHandle LookupMappedRow(const FMapKeyView& Index) const;*/
 
        
    };
} // namespace UE::Editor::DataStorage
 
 
 
 
//
// Implementations
//
 
namespace UE::Editor::DataStorage
{
    //
    // ICommonQueryContext
    //
 
    template<TDataColumnType Column>
    const Column* ICommonQueryContext::GetColumn() const
    {
        return reinterpret_cast<const Column*>(GetColumn(Column::StaticStruct()));
    }
 
    template <TDynamicColumnTemplate TemplateType>
    const TemplateType* ICommonQueryContext::GetColumn(const FName& Identifier) const
    {
        const UScriptStruct* DynamicColumnType = FindDynamicColumnType<TemplateType>(Identifier);
        return static_cast<const TemplateType*>(GetColumn(DynamicColumnType));
    }
 
    template<typename Column>
    Column* ICommonQueryContext::GetMutableColumn()
    {
        return reinterpret_cast<Column*>(GetMutableColumn(Column::StaticStruct()));
    }
 
    template <TDynamicColumnTemplate TemplateType>
    TemplateType* ICommonQueryContext::GetMutableColumn(const FName& Identifier)
    {
        const UScriptStruct* DynamicColumnType = FindDynamicColumnType<TemplateType>(Identifier);
        return static_cast<TemplateType*>(GetMutableColumn(DynamicColumnType));
    }
 
    template <typename Column>
    bool ICommonQueryContext::HasColumn() const
    {
        return HasColumn(Column::StaticStruct());
    }
 
    template <typename Column>
    bool ICommonQueryContext::HasColumn(RowHandle Row) const
    {
        return HasColumn(Row, Column::StaticStruct());
    }
 
    template <TDynamicColumnTemplate DynamicColumnTemplate>
    bool ICommonQueryContext::HasColumn(RowHandle Row, const FName& Identifier) const
    {
        if (const UScriptStruct* DynamicColumnType = FindDynamicColumnType<DynamicColumnTemplate>(Identifier))
        {
            return HasColumn(DynamicColumnType);
        }
        return false;
    }
 
    template <TDynamicColumnTemplate TemplateType>
    const UScriptStruct* ICommonQueryContext::FindDynamicColumnType(const FName& Identifier) const
    {
        return FindDynamicColumnType(FDynamicColumnDescription
            {
                .TemplateType = TemplateType::StaticStruct(),
                .Identifier = Identifier
            });
    }
 
    template <typename DynamicColumnTemplate>
    const DynamicColumnTemplate* ICommonQueryWithEnvironmentContext::GetColumn(const FName& Identifier) const
    {
        using namespace UE::Editor::DataStorage;
        const FDynamicColumnDescription Description
        {
            .TemplateType = DynamicColumnTemplate::StaticStruct(),
            .Identifier = Identifier
        };
        const UScriptStruct* StructInfo = FindDynamicColumnType(Description);
        if (StructInfo)
        {
            const void* ColumnData = GetColumn(StructInfo);
            return static_cast<const DynamicColumnTemplate*>(ColumnData);
        }
        return nullptr;
    }
 
    template <typename DynamicColumnTemplate>
    DynamicColumnTemplate* ICommonQueryWithEnvironmentContext::GetMutableColumn(const FName& Identifier)
    {
        using namespace UE::Editor::DataStorage;
        const FDynamicColumnDescription Description
        {
            .TemplateType = DynamicColumnTemplate::StaticStruct(),
            .Identifier = Identifier
        };
        const UScriptStruct* StructInfo = FindDynamicColumnType(Description);
        if (StructInfo)
        {
            const void* ColumnData = GetMutableColumn(StructInfo);
            return static_cast<const DynamicColumnTemplate*>(ColumnData);
        }
        return nullptr;
    }
 
    template <typename DynamicColumnTemplate>
    bool ICommonQueryWithEnvironmentContext::HasColumn(const FName& Identifier) const
    {
        using namespace UE::Editor::DataStorage;
        const FDynamicColumnDescription Description
        {
            .TemplateType = DynamicColumnTemplate::StaticStruct(),
            .Identifier = Identifier
        };
        const UScriptStruct* StructInfo = FindDynamicColumnType(Description);
        if (StructInfo)
        {
            return ICommonQueryContext::HasColumn(StructInfo);
        }
        return false;
    }
 
    template <typename DynamicColumnTemplate>
    bool ICommonQueryWithEnvironmentContext::HasColumn(RowHandle Row, const FName& Identifier) const
    {
        using namespace UE::Editor::DataStorage;
        const FDynamicColumnDescription Description
        {
            .TemplateType = DynamicColumnTemplate::StaticStruct(),
            .Identifier = Identifier
        };
        const UScriptStruct* StructInfo = FindDynamicColumnType(Description);
        if (StructInfo)
        {
            return ICommonQueryContext::HasColumn(Row, StructInfo);
        }
        return false;
    }
 
    //
    // ICommonQueryWithEnvironmentContext
    // 
 
    template<typename ColumnType>
    ColumnType& ICommonQueryWithEnvironmentContext::AddColumn(RowHandle Row, ColumnType&& Column)
    {
        const UScriptStruct* TypeInfo = ColumnType::StaticStruct();
 
        if constexpr (std::is_move_constructible_v<ColumnType>)
        {
            void* Address = AddColumnUninitialized(Row, TypeInfo,
                [](const UScriptStruct&, void* Destination, void* Source)
                {
                    *reinterpret_cast<ColumnType*>(Destination) = MoveTemp(*reinterpret_cast<ColumnType*>(Source));
                });
            return *(new(Address) ColumnType(Forward<ColumnType>(Column)));
        }
        else
        {
            void* Address = AddColumnUninitialized(Row, TypeInfo);
            TypeInfo->CopyScriptStruct(Address, &Column);
            return *reinterpret_cast<ColumnType*>(Address);
        }
    }
 
    template <typename ColumnTypeTemplate>
    ColumnTypeTemplate* ICommonQueryWithEnvironmentContext::AddColumn(RowHandle Row, const FName& Identifier)
    {
        const UScriptStruct* TemplateType = ColumnTypeTemplate::StaticStruct();
        const FDynamicColumnDescription Description
        {
            .TemplateType = TemplateType,
            .Identifier = Identifier
        };
 
        if constexpr (TDataColumnType<ColumnTypeTemplate>)
        {
            ColumnTypeTemplate* ColumnData = static_cast<ColumnTypeTemplate*>(AddColumnUninitialized(Row, Description));
            new (ColumnData) ColumnTypeTemplate();
            return ColumnData;
        }
        if constexpr (TTagColumnType<ColumnTypeTemplate>)
        {
            AddColumns({Row}, {Description});
            return nullptr;
        }
 
        return  nullptr;
    }
 
    template <typename ColumnTypeTemplate>
    ColumnTypeTemplate& ICommonQueryWithEnvironmentContext::AddColumn(RowHandle Row, const FName& Identifier, ColumnTypeTemplate&& Column)
    {
        const UScriptStruct* TemplateType = ColumnTypeTemplate::StaticStruct();
        const FDynamicColumnDescription Description
        {
            .TemplateType = TemplateType,
            .Identifier = Identifier
        };
 
        if constexpr (std::is_move_constructible_v<ColumnTypeTemplate>)
        {
            void* Address = AddColumnUninitialized(Row, Description,
                [](const UScriptStruct&, void* Destination, void* Source)
                {
                    *static_cast<ColumnTypeTemplate*>(Destination) = MoveTemp(*static_cast<ColumnTypeTemplate*>(Source));
                });
            return *(new(Address) ColumnTypeTemplate(Forward<ColumnTypeTemplate>(Column)));
        }
        else
        {
            void* Address = AddColumnUninitialized(Row, Description);
            new (Address) ColumnTypeTemplate(Forward<ColumnTypeTemplate>(Column));
            return *static_cast<ColumnTypeTemplate*>(Address);
        }
    }
 
    template<typename... Columns>
    void ICommonQueryWithEnvironmentContext::AddColumns(RowHandle Row)
    {
        AddColumns(Row, { Columns::StaticStruct()... });
    }
 
    template<typename... Columns>
    void ICommonQueryWithEnvironmentContext::AddColumns(TConstArrayView<RowHandle> Rows)
    {
        AddColumns(Rows, { Columns::StaticStruct()... });
    }
 
    template<typename... Columns>
    void ICommonQueryWithEnvironmentContext::RemoveColumns(RowHandle Row)
    {
        RemoveColumns(Row, { Columns::StaticStruct()... });
    }
 
    template<typename... Columns>
    void ICommonQueryWithEnvironmentContext::RemoveColumns(TConstArrayView<RowHandle> Rows)
    {
        RemoveColumns(Rows, { Columns::StaticStruct()... });
    }
 
    template <typename T>
    void ICommonQueryContext::PushCommand(T CommandContext)
    {
        if constexpr(std::is_empty_v<T>)
        {
            // The command object doesn't hold any arguments so use a cheaper path that only stores the callback.
            PushCommand(
                [](void*)
                {
                    T Instance;
                    Instance->operator()();
                }, nullptr);
        }
        else
        {
            // Wrapper lambda to store the type and call operator().
            auto CommandFunction = [](void* InInstanceOfT)
                {
                    T* Instance = static_cast<T*>(InInstanceOfT);
                    Instance->operator()();
                };
 
            FEmplaceObjectParams Params;
 
            Params.ObjectSize = sizeof(T);
            Params.Alignment = alignof(T);
            Params.Construct = [](void* Destination, void* SourceCommandContext)
            {
                T& SourceCommand = *static_cast<T*>(SourceCommandContext);
                new (Destination) T(MoveTemp(SourceCommand));
            };
            if (std::is_trivially_destructible_v<T>)
            {
                Params.Destroy = nullptr;
            }
            else
            {
                Params.Destroy = [](void* EmplacedObject)
                {
                    static_cast<T*>(EmplacedObject)->~T();
                };
            }
                
            Params.SourceObject = &CommandContext;
                
            void* EmplacedCommandContext = EmplaceObjectInScratch(Params);
            PushCommand(CommandFunction, EmplacedCommandContext);
        }
    }
 
 
 
    //
    // IQueryContext
    //
 
    /*RowHandle IQueryContext::FindIndexedRow(IndexHash Index) const
    {
        return LookupMappedRow(NAME_None, FMapKeyView(Index));
    }
 
    RowHandle IQueryContext::LookupMappedRow(const FMapKeyView& Index) const
    {
        return LookupMappedRow(NAME_None, FMapKeyView(Index));
    }*/
 
} // namespace UE::Editor::DataStorage