TypedElementQueryBuilder.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "DataStorage/CommonTypes.h"
#include "Elements/Interfaces/TypedElementDataStorageInterface.h"
#include "Templates/SubclassOf.h"
#include "UObject/WeakObjectPtrTemplates.h"
 
class UScriptStruct;
class USubsystem;
 
namespace UE::Editor::DataStorage::Queries
{
    TYPEDELEMENTFRAMEWORK_API const UScriptStruct* Type(FTopLevelAssetPath Name);
    TYPEDELEMENTFRAMEWORK_API const UScriptStruct* TypeOptional(FTopLevelAssetPath Name);
    TYPEDELEMENTFRAMEWORK_API const UScriptStruct* operator""_Type(const char* Name, std::size_t NameSize);
    TYPEDELEMENTFRAMEWORK_API const UScriptStruct* operator""_TypeOptional(const char* Name, std::size_t NameSize);
 
    enum class EOptional
    {
        No,
        Yes
    };
 
    class FDependency final
    {
        friend class Count;
        friend class Select;
        friend class FSimpleQuery;
        friend class FQueryConditionQuery;
    public:
        template<typename... TargetTypes>
        FDependency& ReadOnly();
        TYPEDELEMENTFRAMEWORK_API FDependency& ReadOnly(const UClass* Target);
        TYPEDELEMENTFRAMEWORK_API FDependency& ReadOnly(TConstArrayView<const UClass*> Targets);
        template<typename... TargetTypes>
        FDependency& ReadWrite();
        TYPEDELEMENTFRAMEWORK_API FDependency& ReadWrite(const UClass* Target);
        TYPEDELEMENTFRAMEWORK_API FDependency& ReadWrite(TConstArrayView<const UClass*> Targets);
 
        TYPEDELEMENTFRAMEWORK_API FDependency& SubQuery(QueryHandle Handle);
        TYPEDELEMENTFRAMEWORK_API FDependency& SubQuery(TConstArrayView<QueryHandle> Handles);
 
        TYPEDELEMENTFRAMEWORK_API FQueryDescription&& Compile();
 
    private:
        TYPEDELEMENTFRAMEWORK_API explicit FDependency(FQueryDescription* Query);
 
        FQueryDescription* Query;
    };
 
    class FSimpleQuery final
    {
    public:
        friend class Count;
        friend class Select;
 
        TYPEDELEMENTFRAMEWORK_API FDependency DependsOn();
        TYPEDELEMENTFRAMEWORK_API FQueryDescription&& Compile();
 
        template<TColumnType... TargetTypes>
        FSimpleQuery& All();
        TYPEDELEMENTFRAMEWORK_API FSimpleQuery& All(const UScriptStruct* Target);
        TYPEDELEMENTFRAMEWORK_API FSimpleQuery& All(TConstArrayView<const UScriptStruct*> Targets);
        
        template<TColumnType... TargetTypes>
        FSimpleQuery& Any();
        TYPEDELEMENTFRAMEWORK_API FSimpleQuery& Any(const UScriptStruct* Target);
        TYPEDELEMENTFRAMEWORK_API FSimpleQuery& Any(TConstArrayView<const UScriptStruct*> Targets);
 
        // Dynamic Column Support
        TYPEDELEMENTFRAMEWORK_API FSimpleQuery& Any(const FDynamicColumnDescription& Description);
        template<TDynamicColumnTemplate T>
        FSimpleQuery& Any(const FName&);
 
        // ValueTags not yet supported for Any
        template<TValueTagType>
        FSimpleQuery& Any(const FName&) = delete;
        template<TValueTagType>
        FSimpleQuery& Any(const FName&, const FName&) = delete;
        
        template<TColumnType... TargetTypes>
        FSimpleQuery& None();
        
        TYPEDELEMENTFRAMEWORK_API FSimpleQuery& None(const UScriptStruct* Target);
        TYPEDELEMENTFRAMEWORK_API FSimpleQuery& None(TConstArrayView<const UScriptStruct*> Targets);
        
        // ValueTags not yet supported for None
        template<TValueTagType>
        FSimpleQuery& None(const FName& Tag) = delete;
        template<TValueTagType>
        FSimpleQuery& None(const FName& Tag, const FName& Value) = delete;
 
        // Dynamic Column Support
        TYPEDELEMENTFRAMEWORK_API FSimpleQuery& None(const FDynamicColumnDescription& Description);
        template<TDynamicColumnTemplate T>
        FSimpleQuery& None(const FName&);
        
        // Value Tags
        // ============
        // Adds a filter to the query which must match a given ValueTag.  The value of the ValueTag will not be checked.
        TYPEDELEMENTFRAMEWORK_API FSimpleQuery& All(const FValueTag& Tag);
        // Adds a filter to the query which must match a given ValueTag.  The value of the ValueTag must also match.
        // Note: The query can only match a single value.  Multiple value queries are not supported at this time.
        TYPEDELEMENTFRAMEWORK_API FSimpleQuery& All(const FValueTag& Tag, const FName& Value);
        
        TYPEDELEMENTFRAMEWORK_API FSimpleQuery& All(const UEnum& Enum);
        TYPEDELEMENTFRAMEWORK_API FSimpleQuery& All(const UEnum& Enum, int64 Value);
 
        // Dynamic Column support
        TYPEDELEMENTFRAMEWORK_API FSimpleQuery& All(const FDynamicColumnDescription& Description);
        template<TDynamicColumnTemplate T>
        FSimpleQuery& All(const FName&);
 
        // Adds a filter to the query which must match a given ValueTag.  The value of the DynamicTag will not be checked.
        template<TValueTagType>
        FSimpleQuery& All(const FName& Tag);
        // Adds a filter to the query which must match a given ValueTag.  The value of the DynamicTag must also match.
        // Note: The query can only match a single value.  Multiple value queries are not supported at this time.
        template<TValueTagType>
        FSimpleQuery& All(const FName& Tag, const FName& Value);
        
        template<TEnumType EnumT>
        FSimpleQuery& All();
        
        template<TEnumType EnumT>
        FSimpleQuery& All(EnumT EnumValue);
 
        template<auto Value, TEnumType EnumT = decltype(Value)>
        FSimpleQuery& All();
 
    private:
        TYPEDELEMENTFRAMEWORK_API explicit FSimpleQuery(FQueryDescription* Query);
 
        FQueryDescription* Query;
    };
 
    struct FQueryCallbackType{};
 
    struct FProcessor final : public FQueryCallbackType
    {
        TYPEDELEMENTFRAMEWORK_API FProcessor(EQueryTickPhase Phase, FName Group);
        TYPEDELEMENTFRAMEWORK_API FProcessor& SetPhase(EQueryTickPhase NewPhase);
        TYPEDELEMENTFRAMEWORK_API FProcessor& SetGroup(FName GroupName);
        TYPEDELEMENTFRAMEWORK_API FProcessor& SetBeforeGroup(FName GroupName);
        TYPEDELEMENTFRAMEWORK_API FProcessor& SetAfterGroup(FName GroupName);
        TYPEDELEMENTFRAMEWORK_API FProcessor& SetExecutionMode(EExecutionMode Mode);
        TYPEDELEMENTFRAMEWORK_API FProcessor& MakeActivatable(FName Name);
        TYPEDELEMENTFRAMEWORK_API FProcessor& BatchModifications(bool bBatch);
 
        EQueryTickPhase Phase;
        FName Group;
        FName BeforeGroup;
        FName AfterGroup;
        FName ActivationName;
        EExecutionMode ExecutionMode = EExecutionMode::Default;
        bool bBatchModifications = false;
    };
 
    struct FObserver final : public FQueryCallbackType
    {
        enum class EEvent : uint8
        {
            Add,
            Remove
        };
 
        TYPEDELEMENTFRAMEWORK_API FObserver(EEvent MonitorForEvent, const UScriptStruct* MonitoredColumn);
 
        template<TColumnType ColumnType>
        static FObserver OnAdd();
        template<TColumnType ColumnType>
        static FObserver OnRemove();
 
        TYPEDELEMENTFRAMEWORK_API FObserver& SetEvent(EEvent MonitorForEvent);
        TYPEDELEMENTFRAMEWORK_API FObserver& SetMonitoredColumn(const UScriptStruct* MonitoredColumn);
        template<TColumnType ColumnType>
        FObserver& SetMonitoredColumn();
        TYPEDELEMENTFRAMEWORK_API FObserver& SetExecutionMode(EExecutionMode Mode);
        TYPEDELEMENTFRAMEWORK_API FObserver& MakeActivatable(FName Name);
 
        const UScriptStruct* Monitor;
        EEvent Event;
        FName ActivationName;
        EExecutionMode ExecutionMode = EExecutionMode::Default;
    };
 
    struct FPhaseAmble final : public FQueryCallbackType
    {
        enum class ELocation : uint8
        {
            Preamble,
            Postamble
        };
 
        TYPEDELEMENTFRAMEWORK_API FPhaseAmble(ELocation InLocation, EQueryTickPhase InPhase);
        TYPEDELEMENTFRAMEWORK_API FPhaseAmble& SetLocation(ELocation NewLocation);
        TYPEDELEMENTFRAMEWORK_API FPhaseAmble& SetPhase(EQueryTickPhase NewPhase);
        TYPEDELEMENTFRAMEWORK_API FPhaseAmble& SetExecutionMode(EExecutionMode Mode);
        TYPEDELEMENTFRAMEWORK_API FPhaseAmble& MakeActivatable(FName Name);
 
        EQueryTickPhase Phase;
        ELocation Location;
        FName ActivationName;
        EExecutionMode ExecutionMode = EExecutionMode::Default;
    };
 
    // Because this is a thin wrapper called from within a query callback, it's better to inline fully so all
    // function pre/postambles can be optimized away.
    struct FQueryContextForwarder : public IQueryContext
    {
        inline FQueryContextForwarder(
            const FQueryDescription& InDescription, 
            IQueryContext& InParentContext);
        inline ~FQueryContextForwarder() = default;
 
        inline const void* GetColumn(const UScriptStruct* ColumnType) const override;
        inline void* GetMutableColumn(const UScriptStruct* ColumnType) override;
        inline void GetColumns(TArrayView<char*> RetrievedAddresses, TConstArrayView<TWeakObjectPtr<const UScriptStruct>> ColumnTypes,
            TConstArrayView<EQueryAccessType> AccessTypes) override;
        inline void GetColumnsUnguarded(int32 TypeCount, char** RetrievedAddresses, const TWeakObjectPtr<const UScriptStruct>* ColumnTypes,
            const EQueryAccessType* AccessTypes) override;
 
        inline bool HasColumn(const UScriptStruct* ColumnType) const override;
        
        inline UObject* GetMutableDependency(const UClass* DependencyClass) override;
        inline const UObject* GetDependency(const UClass* DependencyClass) override;
        inline void GetDependencies(TArrayView<UObject*> RetrievedAddresses, TConstArrayView<TWeakObjectPtr<const UClass>> SubsystemTypes,
            TConstArrayView<EQueryAccessType> AccessTypes) override;
 
        inline uint32 GetRowCount() const override;
        inline TConstArrayView<RowHandle> GetRowHandles() const override;
        inline void RemoveRow(RowHandle Row) override;
        inline void RemoveRows(TConstArrayView<RowHandle> Rows) override;
 
        inline void AddColumns(RowHandle Row, TConstArrayView<const UScriptStruct*> ColumnTypes) override;
        inline void AddColumns(TConstArrayView<RowHandle> Rows, TConstArrayView<const UScriptStruct*> ColumnTypes) override;
        inline void RemoveColumns(RowHandle Row, TConstArrayView<const UScriptStruct*> ColumnTypes) override;
        inline void RemoveColumns(TConstArrayView<RowHandle> Rows, TConstArrayView<const UScriptStruct*> ColumnTypes) override;
 
        inline void PushCommand(void(* CommandFunction)(void*), void* CommandData) override;
 
        inline FQueryResult RunQuery(QueryHandle Query) override;
        inline FQueryResult RunSubquery(int32 SubqueryIndex) override;
        inline FQueryResult RunSubquery(int32 SubqueryIndex, SubqueryCallbackRef Callback) override;
        inline FQueryResult RunSubquery(int32 SubqueryIndex, RowHandle Row,
            SubqueryCallbackRef Callback) override;
 
        IQueryContext& ParentContext;
        const FQueryDescription& Description;
    };
 
    template<typename... Dependencies>
    struct FCachedQueryContext final : public FQueryContextForwarder
    {
        explicit FCachedQueryContext(
            const FQueryDescription& InDescription, 
            IQueryContext& InParentContext);
        
        static void Register(FQueryDescription& Query);
 
        template<typename Dependency>
        Dependency& GetCachedMutableDependency();
        template<typename Dependency>
        const Dependency& GetCachedDependency() const;
    };
 
    class FQueryConditionQuery
    {
    public:
        friend class Count;
        friend class Select;
 
        TYPEDELEMENTFRAMEWORK_API FDependency DependsOn();
        TYPEDELEMENTFRAMEWORK_API FQueryDescription&& Compile();
    private:
        TYPEDELEMENTFRAMEWORK_API explicit FQueryConditionQuery(FQueryDescription* Query);
 
        FQueryDescription* Query;
    };
 
    // Explicitly not following the naming convention in order to present this as a query that can be read as such.
    class Select final
    {
    public:
        TYPEDELEMENTFRAMEWORK_API Select();
 
        template<typename CallbackType, typename Function>
        Select(FName Name, const CallbackType& Type, Function&& Callback);
        template<typename CallbackType, typename Class, typename Function>
        Select(FName Name, const CallbackType& Type, Class* Instance, Function&& Callback);
 
        template<TDataColumnType... TargetTypes>
        Select& ReadOnly();
        TYPEDELEMENTFRAMEWORK_API Select& ReadOnly(const UScriptStruct* Target);
        TYPEDELEMENTFRAMEWORK_API Select& ReadOnly(TConstArrayView<const UScriptStruct*> Targets);
        TYPEDELEMENTFRAMEWORK_API Select& ReadOnly(const FDynamicColumnDescription& Description);
        template<TDataColumnType... TargetTypes>
        Select& ReadOnly(EOptional Optional);
        TYPEDELEMENTFRAMEWORK_API Select& ReadOnly(const UScriptStruct* Target, EOptional Optional);
        TYPEDELEMENTFRAMEWORK_API Select& ReadOnly(TConstArrayView<const UScriptStruct*> Targets, EOptional Optional);
        template<TDynamicColumnTemplate Target>
        Select& ReadOnly(const FName& Identifier);
        template<TDynamicColumnTemplate Target>
        Select& ReadOnly();
        template<TDataColumnType... TargetTypes>
        Select& ReadWrite();
        TYPEDELEMENTFRAMEWORK_API Select& ReadWrite(const UScriptStruct* Target);
        TYPEDELEMENTFRAMEWORK_API Select& ReadWrite(TConstArrayView<const UScriptStruct*> Targets);
        TYPEDELEMENTFRAMEWORK_API Select& ReadWrite(const FDynamicColumnDescription& Description);
        template<TDynamicColumnTemplate Target>
        Select& ReadWrite(const FName& Identifier);
        template<TDynamicColumnTemplate Target>
        Select& ReadWrite();
 
        // Query Condition API
        TYPEDELEMENTFRAMEWORK_API FQueryConditionQuery Where(const Queries::FConditions& Condition);
 
        TYPEDELEMENTFRAMEWORK_API FQueryDescription&& Compile();
        TYPEDELEMENTFRAMEWORK_API FSimpleQuery Where();
        TYPEDELEMENTFRAMEWORK_API FDependency DependsOn();
        TYPEDELEMENTFRAMEWORK_API Select& AccessesHierarchy(const FName& HierarchyName);
 
    private:
        FQueryDescription Query;
    };
 
    // Explicitly not following the naming convention in order to keep readability consistent. It now reads like a query sentence.
    class Count final
    {
    public:
        TYPEDELEMENTFRAMEWORK_API Count();
 
        TYPEDELEMENTFRAMEWORK_API FSimpleQuery Where();
        TYPEDELEMENTFRAMEWORK_API FDependency DependsOn();
 
    private:
        FQueryDescription Query;
    };
 
    template<typename Function>
    DirectQueryCallback CreateDirectQueryCallbackBinding(Function&& Callback);
    template<typename Function>
    SubqueryCallback CreateSubqueryCallbackBinding(Function&& Callback);
 
    // Merge the two input queries by copying the source query into the destination query. If the merge is not possible the original data will be
    // preserved and an optional error message can be requested
    TYPEDELEMENTFRAMEWORK_API bool MergeQueries(FQueryDescription& Destination, const FQueryDescription& Source, FText* OutErrorMessage = nullptr);
 
} // namespace UE::Editor::DataStorage::Queries
 
#include "Elements/Framework/TypedElementQueryBuilder.inl"