GameplayTagContainer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_4
#include "CoreMinimal.h"
#endif //UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_4
#include "Stats/Stats.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "UObject/Class.h"
#include "Misc/ComparisonUtility.h"
#include "GameplayTagContainer.generated.h"
 
class UEditableGameplayTagQuery;
struct FGameplayTagContainer;
class FJsonObject;
struct FPropertyTag;
 
GAMEPLAYTAGS_API DECLARE_LOG_CATEGORY_EXTERN(LogGameplayTags, Log, All);
 
DECLARE_STATS_GROUP(TEXT("Gameplay Tags"), STATGROUP_GameplayTags, STATCAT_Advanced);
 
DECLARE_CYCLE_STAT_EXTERN(TEXT("FGameplayTagContainer::DoesTagContainerMatch"), STAT_FGameplayTagContainer_DoesTagContainerMatch, STATGROUP_GameplayTags, GAMEPLAYTAGS_API);
 
UENUM(BlueprintType)
enum class EGameplayContainerMatchType : uint8
{
    //  Means the filter is populated by any tag matches in this container.
    Any,    
 
    //  Means the filter is only populated if all of the tags in this container match.
    All     
};
 
typedef uint16 FGameplayTagNetIndex;
#define INVALID_TAGNETINDEX MAX_uint16
 
USTRUCT(BlueprintType, meta = (HasNativeMake = "/Script/GameplayTags.BlueprintGameplayTagLibrary.MakeLiteralGameplayTag", HasNativeBreak = "/Script/GameplayTags.BlueprintGameplayTagLibrary.GetTagName", DisableSplitPin))
struct FGameplayTag
{
    GENERATED_USTRUCT_BODY()
 
    
    FGameplayTag()
    {
    }
 
    static GAMEPLAYTAGS_API FGameplayTag RequestGameplayTag(const FName& TagName, bool ErrorIfNotFound=true);
 
    static GAMEPLAYTAGS_API bool IsValidGameplayTagString(const FString& TagString, FText* OutError = nullptr, FString* OutFixedString = nullptr);
 
    inline bool operator==(FGameplayTag const& Other) const
    {
        return TagName == Other.TagName;
    }
 
    inline bool operator!=(FGameplayTag const& Other) const
    {
        return TagName != Other.TagName;
    }
 
    inline bool operator<(FGameplayTag const& Other) const
    {
        return UE::ComparisonUtility::CompareWithNumericSuffix(TagName, Other.TagName) < 0;
    }
 
    GAMEPLAYTAGS_API bool MatchesTag(const FGameplayTag& TagToCheck) const;
 
    inline bool MatchesTagExact(const FGameplayTag& TagToCheck) const
    {
        if (!TagToCheck.IsValid())
        {
            return false;
        }
        // Only check explicit tag list
        return TagName == TagToCheck.TagName;
    }
 
    GAMEPLAYTAGS_API int32 MatchesTagDepth(const FGameplayTag& TagToCheck) const;
 
    GAMEPLAYTAGS_API bool MatchesAny(const FGameplayTagContainer& ContainerToCheck) const;
 
    bool MatchesAnyExact(const FGameplayTagContainer& ContainerToCheck) const;
 
    inline bool IsValid() const
    {
        return (TagName != NAME_None);
    }
 
    GAMEPLAYTAGS_API FGameplayTagContainer GetSingleTagContainer() const;
 
    GAMEPLAYTAGS_API FGameplayTag RequestDirectParent() const;
 
    GAMEPLAYTAGS_API FGameplayTagContainer GetGameplayTagParents() const;
 
    GAMEPLAYTAGS_API void ParseParentTags(TArray<FGameplayTag>& UniqueParentTags) const;
 
    GAMEPLAYTAGS_API FName GetTagLeafName() const;
 
    inline friend uint32 GetTypeHash(const FGameplayTag& Tag)
    {
        return GetTypeHash(Tag.TagName);
    }
 
    inline FString ToString() const
    {
        return TagName.ToString();
    }
 
    inline FName GetTagName() const
    {
        return TagName;
    }
 
    friend FArchive& operator<<(FArchive& Ar, FGameplayTag& GameplayTag)
    {
        return Ar << GameplayTag.TagName;
    }
 
    friend void operator<<(FStructuredArchive::FSlot Slot, FGameplayTag& GameplayTag)
    {
        Slot << GameplayTag.TagName;
    }
 
    GAMEPLAYTAGS_API bool NetSerialize(FArchive& Ar, class UPackageMap* Map, bool& bOutSuccess);
 
    GAMEPLAYTAGS_API void PostSerialize(const FArchive& Ar);
    GAMEPLAYTAGS_API bool NetSerialize_Packed(FArchive& Ar, class UPackageMap* Map, bool& bOutSuccess);
 
    GAMEPLAYTAGS_API bool SerializeFromMismatchedTag(const FPropertyTag& Tag, FStructuredArchive::FSlot Slot);
 
    GAMEPLAYTAGS_API void FromExportString(const FString& ExportString, int32 PortFlags = 0);
 
    GAMEPLAYTAGS_API bool ImportTextItem(const TCHAR*& Buffer, int32 PortFlags, UObject* Parent, FOutputDevice* ErrorText);
 
    static GAMEPLAYTAGS_API const FGameplayTag EmptyTag;
 
protected:
 
    bool NetSerialize_ForReplayUsingFastReplication(FArchive& Ar, class UPackageMapClient& PackageMapClient);
 
    GAMEPLAYTAGS_API explicit FGameplayTag(const FName& InTagName);
 
    UPROPERTY(VisibleAnywhere, Category = GameplayTags, SaveGame)
    FName TagName;
 
    friend class UGameplayTagsManager;
    friend class FGameplayTagRedirectors;
    friend class FNativeGameplayTag;
    friend struct FGameplayTagContainer;
    friend struct FGameplayTagNode;
};
 
template<>
struct TStructOpsTypeTraits< FGameplayTag > : public TStructOpsTypeTraitsBase2< FGameplayTag >
{
    enum
    {
        WithNetSerializer = true,
        WithNetSharedSerialization = true,
        WithPostSerialize = true,
        WithStructuredSerializeFromMismatchedTag = true,
        WithImportTextItem = true,
    };
};
 
USTRUCT(BlueprintType, meta = (HasNativeMake = "/Script/GameplayTags.BlueprintGameplayTagLibrary.MakeGameplayTagContainerFromArray", HasNativeBreak = "/Script/GameplayTags.BlueprintGameplayTagLibrary.BreakGameplayTagContainer"))
struct FGameplayTagContainer
{
    GENERATED_USTRUCT_BODY()
 
    
    FGameplayTagContainer()
    {
    }
 
    FGameplayTagContainer(FGameplayTagContainer const& Other)
    {
        *this = Other;
    }
 
    explicit FGameplayTagContainer(const FGameplayTag& Tag)
    {
        AddTag(Tag);
    }
 
    FGameplayTagContainer(FGameplayTagContainer&& Other)
        : GameplayTags(MoveTemp(Other.GameplayTags))
        , ParentTags(MoveTemp(Other.ParentTags))
    {
 
    }
 
    ~FGameplayTagContainer()
    {
    }
 
    template<class AllocatorType>
    static FGameplayTagContainer CreateFromArray(const TArray<FGameplayTag, AllocatorType>& SourceTags)
    {
        FGameplayTagContainer Container;
        Container.GameplayTags.Append(SourceTags);
        Container.FillParentTags();
        return Container;
    }
 
    GAMEPLAYTAGS_API FGameplayTagContainer& operator=(FGameplayTagContainer const& Other);
    GAMEPLAYTAGS_API FGameplayTagContainer& operator=(FGameplayTagContainer&& Other);
    GAMEPLAYTAGS_API bool operator==(FGameplayTagContainer const& Other) const;
    GAMEPLAYTAGS_API bool operator!=(FGameplayTagContainer const& Other) const;
 
    inline bool HasTag(const FGameplayTag& TagToCheck) const
    {
        if (!TagToCheck.IsValid())
        {
            return false;
        }
        // Check explicit and parent tag list 
        return GameplayTags.Contains(TagToCheck) || ParentTags.Contains(TagToCheck);
    }
 
    inline bool HasTagExact(const FGameplayTag& TagToCheck) const
    {
        if (!TagToCheck.IsValid())
        {
            return false;
        }
        // Only check check explicit tag list
        return GameplayTags.Contains(TagToCheck);
    }
 
    inline bool HasAny(const FGameplayTagContainer& ContainerToCheck) const
    {
        if (ContainerToCheck.IsEmpty())
        {
            return false;
        }
        for (const FGameplayTag& OtherTag : ContainerToCheck.GameplayTags)
        {
            if (GameplayTags.Contains(OtherTag) || ParentTags.Contains(OtherTag))
            {
                return true;
            }
        }
        return false;
    }
 
    inline bool HasAnyExact(const FGameplayTagContainer& ContainerToCheck) const
    {
        if (ContainerToCheck.IsEmpty())
        {
            return false;
        }
        for (const FGameplayTag& OtherTag : ContainerToCheck.GameplayTags)
        {
            if (GameplayTags.Contains(OtherTag))
            {
                return true;
            }
        }
        return false;
    }
 
    inline bool HasAll(const FGameplayTagContainer& ContainerToCheck) const
    {
        if (ContainerToCheck.IsEmpty())
        {
            return true;
        }
        for (const FGameplayTag& OtherTag : ContainerToCheck.GameplayTags)
        {
            if (!GameplayTags.Contains(OtherTag) && !ParentTags.Contains(OtherTag))
            {
                return false;
            }
        }
        return true;
    }
 
    inline bool HasAllExact(const FGameplayTagContainer& ContainerToCheck) const
    {
        if (ContainerToCheck.IsEmpty())
        {
            return true;
        }
        for (const FGameplayTag& OtherTag : ContainerToCheck.GameplayTags)
        {
            if (!GameplayTags.Contains(OtherTag))
            {
                return false;
            }
        }
        return true;
    }
 
    inline int32 Num() const
    {
        return GameplayTags.Num();
    }
 
    inline bool IsValid() const
    {
        return GameplayTags.Num() > 0;
    }
 
    inline bool IsEmpty() const
    {
        return GameplayTags.Num() == 0;
    }
 
    GAMEPLAYTAGS_API FGameplayTagContainer GetGameplayTagParents() const;
 
    GAMEPLAYTAGS_API FGameplayTagContainer Filter(const FGameplayTagContainer& OtherContainer) const;
 
    GAMEPLAYTAGS_API FGameplayTagContainer FilterExact(const FGameplayTagContainer& OtherContainer) const;
 
    GAMEPLAYTAGS_API bool MatchesQuery(const struct FGameplayTagQuery& Query) const;
 
    GAMEPLAYTAGS_API void AppendTags(FGameplayTagContainer const& Other);
 
    GAMEPLAYTAGS_API void AppendMatchingTags(FGameplayTagContainer const& OtherA, FGameplayTagContainer const& OtherB);
 
    GAMEPLAYTAGS_API void AddTag(const FGameplayTag& TagToAdd);
 
    GAMEPLAYTAGS_API void AddTagFast(const FGameplayTag& TagToAdd);
 
    GAMEPLAYTAGS_API bool AddLeafTag(const FGameplayTag& TagToAdd);
 
    GAMEPLAYTAGS_API bool RemoveTag(const FGameplayTag& TagToRemove, bool bDeferParentTags=false);
 
    GAMEPLAYTAGS_API void RemoveTags(const FGameplayTagContainer& TagsToRemove);
 
    GAMEPLAYTAGS_API void Reset(int32 Slack = 0);
    
    GAMEPLAYTAGS_API bool Serialize(FStructuredArchive::FSlot Slot);
 
    GAMEPLAYTAGS_API bool NetSerialize(FArchive& Ar, class UPackageMap* Map, bool& bOutSuccess);
 
    GAMEPLAYTAGS_API bool ImportTextItem(const TCHAR*& Buffer, int32 PortFlags, UObject* Parent, FOutputDevice* ErrorText);
 
    GAMEPLAYTAGS_API void PostScriptConstruct();
 
    GAMEPLAYTAGS_API FString ToString() const;
 
    GAMEPLAYTAGS_API void FromExportString(const FString& ExportString, int32 PortFlags = 0);
 
    GAMEPLAYTAGS_API FString ToStringSimple(bool bQuoted = false) const;
 
    GAMEPLAYTAGS_API TArray<FString> ToStringsMaxLen(int32 MaxLen) const;
 
    GAMEPLAYTAGS_API FText ToMatchingText(EGameplayContainerMatchType MatchType, bool bInvertCondition) const;
 
    void GetGameplayTagArray(TArray<FGameplayTag>& InOutGameplayTags) const
    {
        InOutGameplayTags = GameplayTags;
    }
 
    GAMEPLAYTAGS_API const TArray<FGameplayTag>& GetGameplayTagArray() const;
 
    TArray<FGameplayTag>::TConstIterator CreateConstIterator() const
    {
        return GameplayTags.CreateConstIterator();
    }
 
    bool IsValidIndex(int32 Index) const
    {
        return GameplayTags.IsValidIndex(Index);
    }
 
    FGameplayTag GetByIndex(int32 Index) const
    {
        if (IsValidIndex(Index))
        {
            return GameplayTags[Index];
        }
        return FGameplayTag();
    }   
 
    FGameplayTag First() const
    {
        return GameplayTags.Num() > 0 ? GameplayTags[0] : FGameplayTag();
    }
 
    FGameplayTag Last() const
    {
        return GameplayTags.Num() > 0 ? GameplayTags.Last() : FGameplayTag();
    }
 
    GAMEPLAYTAGS_API void FillParentTags();
 
    static GAMEPLAYTAGS_API const FGameplayTagContainer EmptyContainer;
 
protected:
 
    bool RemoveTagByExplicitName(const FName& TagName);
 
    UE_DEPRECATED(5.4, "Use ParseParentTags or ExtractParentTags instead")
    GAMEPLAYTAGS_API void AddParentsForTag(const FGameplayTag& Tag);
 
    UPROPERTY(VisibleAnywhere, BlueprintReadWrite, Category=GameplayTags, SaveGame)
    TArray<FGameplayTag> GameplayTags;
 
    UPROPERTY(Transient)
    TArray<FGameplayTag> ParentTags;
 
    friend class UGameplayTagsManager;
    friend class FGameplayTagRedirectors;
    friend struct FGameplayTagQuery;
    friend struct FGameplayTagQueryExpression;
    friend struct FGameplayTagNode;
    friend struct FGameplayTag;
    
private:
 
    inline friend TArray<FGameplayTag>::TConstIterator begin(const FGameplayTagContainer& Array) { return Array.CreateConstIterator(); }
    inline friend TArray<FGameplayTag>::TConstIterator end(const FGameplayTagContainer& Array) { return TArray<FGameplayTag>::TConstIterator(Array.GameplayTags, Array.GameplayTags.Num()); }
};
 
inline bool FGameplayTag::MatchesAnyExact(const FGameplayTagContainer& ContainerToCheck) const
{
    if (ContainerToCheck.IsEmpty())
    {
        return false;
    }
    return ContainerToCheck.GameplayTags.Contains(*this);
}
 
template<>
struct TStructOpsTypeTraits<FGameplayTagContainer> : public TStructOpsTypeTraitsBase2<FGameplayTagContainer>
{
    enum
    {
        WithStructuredSerializer = true,
        WithIdenticalViaEquality = true,
        WithNetSerializer = true,
        WithNetSharedSerialization = true,
        WithImportTextItem = true,
        WithCopy = true,
        WithPostScriptConstruct = true,
    };
    static constexpr EPropertyObjectReferenceType WithSerializerObjectReferences = EPropertyObjectReferenceType::None;
};
 
struct FGameplayTagNativeAdder
{
    GAMEPLAYTAGS_API FGameplayTagNativeAdder();
 
    virtual void AddTags() = 0;
};
 
USTRUCT()
struct FGameplayTagCreationWidgetHelper
{
    GENERATED_USTRUCT_BODY()
};
 
UENUM()
enum class EGameplayTagQueryExprType : uint8
{
    Undefined = 0,
    AnyTagsMatch,
    AllTagsMatch,
    NoTagsMatch,
    AnyExprMatch,
    AllExprMatch,
    NoExprMatch,
    AnyTagsExactMatch,
    AllTagsExactMatch
};
 
namespace EGameplayTagQueryStreamVersion
{
    enum Type
    {
        InitialVersion = 0,
 
        // -----<new versions can be added before this line>-------------------------------------------------
        // - this needs to be the last line (see note below)
        VersionPlusOne,
        LatestVersion = VersionPlusOne - 1
    };
}
 
USTRUCT(BlueprintType, meta=(HasNativeMake="/Script/GameplayTags.BlueprintGameplayTagLibrary.MakeGameplayTagQuery"))
struct FGameplayTagQuery
{
    GENERATED_BODY();
 
public:
    GAMEPLAYTAGS_API FGameplayTagQuery();
 
    GAMEPLAYTAGS_API FGameplayTagQuery(FGameplayTagQuery const& Other);
    GAMEPLAYTAGS_API FGameplayTagQuery(FGameplayTagQuery&& Other);
 
    GAMEPLAYTAGS_API FGameplayTagQuery& operator=(FGameplayTagQuery const& Other);
    GAMEPLAYTAGS_API FGameplayTagQuery& operator=(FGameplayTagQuery&& Other);
 
    GAMEPLAYTAGS_API bool operator==(const FGameplayTagQuery& Other) const;
    GAMEPLAYTAGS_API bool operator!=(const FGameplayTagQuery& Other) const;
 
private:
    // Note: Properties need to be editable to allow FComponentPropertyWriter to serialize them, but are hidden in the editor by the customizations mentioned above.
 
    UPROPERTY(EditAnywhere, Category = Hidden)
    int32 TokenStreamVersion;
 
    UPROPERTY(EditAnywhere, Category = Hidden)
    TArray<FGameplayTag> TagDictionary;
 
    UPROPERTY(EditAnywhere, Category = Hidden)
    TArray<uint8> QueryTokenStream;
 
    UPROPERTY(EditAnywhere, Category = Hidden)
    FString UserDescription;
 
    UPROPERTY(EditAnywhere, Category = Hidden)
    FString AutoDescription;
 
    FGameplayTag GetTagFromIndex(int32 TagIdx) const
    {
        ensure(TagDictionary.IsValidIndex(TagIdx));
        return TagDictionary[TagIdx];
    }
 
public:
 
    void ReplaceTagsFast(FGameplayTagContainer const& Tags)
    {
        ensure(Tags.Num() == TagDictionary.Num());
        TagDictionary.Reset();
        TagDictionary.Append(Tags.GameplayTags);
    }
 
    void ReplaceTagFast(FGameplayTag const& Tag)
    {
        ensure(1 == TagDictionary.Num());
        TagDictionary.Reset();
        TagDictionary.Add(Tag);
    }
 
    GAMEPLAYTAGS_API bool Matches(FGameplayTagContainer const& Tags) const;
 
    GAMEPLAYTAGS_API bool IsEmpty() const;
 
    GAMEPLAYTAGS_API void Clear();
 
    GAMEPLAYTAGS_API void Build(struct FGameplayTagQueryExpression& RootQueryExpr, FString InUserDescription = FString());
 
    static GAMEPLAYTAGS_API FGameplayTagQuery BuildQuery(struct FGameplayTagQueryExpression& RootQueryExpr, FString InDescription = FString());
 
    GAMEPLAYTAGS_API void GetQueryExpr(struct FGameplayTagQueryExpression& OutExpr) const;
 
    GAMEPLAYTAGS_API void Serialize(FArchive& Ar);
    
    void SetUserDescription(const FString& InUserDescription) { UserDescription = InUserDescription; }
 
    const FString& GetDescription() const { return UserDescription.IsEmpty() ? AutoDescription : UserDescription; };
 
    void GetGameplayTagArray(TArray<FGameplayTag>& OutGameplayTags) const
    {
        OutGameplayTags = TagDictionary;
    }
 
    GAMEPLAYTAGS_API const TArray<FGameplayTag>& GetGameplayTagArray() const;
 
#if WITH_EDITOR
    GAMEPLAYTAGS_API void BuildFromEditableQuery(class UEditableGameplayTagQuery& EditableQuery); 
 
    GAMEPLAYTAGS_API UEditableGameplayTagQuery* CreateEditableQuery() const;
#endif // WITH_EDITOR
 
    static GAMEPLAYTAGS_API const FGameplayTagQuery EmptyQuery;
 
    static GAMEPLAYTAGS_API FGameplayTagQuery MakeQuery_MatchAnyTags(FGameplayTagContainer const& InTags);
    static GAMEPLAYTAGS_API FGameplayTagQuery MakeQuery_MatchAllTags(FGameplayTagContainer const& InTags);
    static GAMEPLAYTAGS_API FGameplayTagQuery MakeQuery_MatchNoTags(FGameplayTagContainer const& InTags);
    static GAMEPLAYTAGS_API FGameplayTagQuery MakeQuery_ExactMatchAnyTags(FGameplayTagContainer const& InTags);
    static GAMEPLAYTAGS_API FGameplayTagQuery MakeQuery_ExactMatchAllTags(FGameplayTagContainer const& InTags);
 
    static GAMEPLAYTAGS_API FGameplayTagQuery MakeQuery_MatchTag(FGameplayTag const& InTag);
 
    friend class FQueryEvaluator;
};
 
struct FGameplayTagQueryExpression
{
    FGameplayTagQueryExpression& AnyTagsMatch()
    {
        ExprType = EGameplayTagQueryExprType::AnyTagsMatch;
        return *this;
    }
 
    FGameplayTagQueryExpression& AllTagsMatch()
    {
        ExprType = EGameplayTagQueryExprType::AllTagsMatch;
        return *this;
    }
 
    FGameplayTagQueryExpression& NoTagsMatch()
    {
        ExprType = EGameplayTagQueryExprType::NoTagsMatch;
        return *this;
    }
 
    FGameplayTagQueryExpression& AnyTagsExactMatch()
    {
        ExprType = EGameplayTagQueryExprType::AnyTagsExactMatch;
        return *this;
    }
 
    FGameplayTagQueryExpression& AllTagsExactMatch()
    {
        ExprType = EGameplayTagQueryExprType::AllTagsExactMatch;
        return *this;
    }
 
    FGameplayTagQueryExpression& AnyExprMatch()
    {
        ExprType = EGameplayTagQueryExprType::AnyExprMatch;
        return *this;
    }
 
    FGameplayTagQueryExpression& AllExprMatch()
    {
        ExprType = EGameplayTagQueryExprType::AllExprMatch;
        return *this;
    }
 
    FGameplayTagQueryExpression& NoExprMatch()
    {
        ExprType = EGameplayTagQueryExprType::NoExprMatch;
        return *this;
    }
 
    FGameplayTagQueryExpression& AddTag(TCHAR const* TagString)
    {
        return AddTag(FName(TagString));
    }
    GAMEPLAYTAGS_API FGameplayTagQueryExpression& AddTag(FName TagName);
    FGameplayTagQueryExpression& AddTag(FGameplayTag Tag)
    {
        ensure(UsesTagSet());
        TagSet.Add(Tag);
        return *this;
    }
    
    FGameplayTagQueryExpression& AddTags(FGameplayTagContainer const& Tags)
    {
        ensure(UsesTagSet());
        TagSet.Append(Tags.GameplayTags);
        return *this;
    }
 
    FGameplayTagQueryExpression& AddExpr(FGameplayTagQueryExpression& Expr)
    {
        ensure(UsesExprSet());
        ExprSet.Add(Expr);
        return *this;
    }
    
    GAMEPLAYTAGS_API void EmitTokens(TArray<uint8>& TokenStream, TArray<FGameplayTag>& TagDictionary) const;
 
    EGameplayTagQueryExprType ExprType;
 
    TArray<struct FGameplayTagQueryExpression> ExprSet;
 
    TArray<FGameplayTag> TagSet;
 
    inline bool UsesTagSet() const
    {
        return (ExprType == EGameplayTagQueryExprType::AllTagsMatch) || (ExprType == EGameplayTagQueryExprType::AnyTagsMatch) || (ExprType == EGameplayTagQueryExprType::NoTagsMatch) || (ExprType == EGameplayTagQueryExprType::AnyTagsExactMatch) || (ExprType == EGameplayTagQueryExprType::AllTagsExactMatch);
    }
    inline bool UsesExprSet() const
    {
        return (ExprType == EGameplayTagQueryExprType::AllExprMatch) || (ExprType == EGameplayTagQueryExprType::AnyExprMatch) || (ExprType == EGameplayTagQueryExprType::NoExprMatch);
    }
 
    GAMEPLAYTAGS_API bool ConvertToJsonObject(TSharedRef<FJsonObject>& OutObject) const;
 
    static GAMEPLAYTAGS_API bool MakeFromJsonObject(const TSharedRef<FJsonObject>& InObject, FGameplayTagQueryExpression& OutQueryExpression);
};
 
template<>
struct TStructOpsTypeTraits<FGameplayTagQuery> : public TStructOpsTypeTraitsBase2<FGameplayTagQuery>
{
    enum
    {
        WithCopy = true
    };
};
 
 
 
UCLASS(editinlinenew, collapseCategories, Transient, MinimalAPI) 
class UEditableGameplayTagQuery : public UObject
{
    GENERATED_BODY()
 
public:
    UPROPERTY(EditDefaultsOnly, Category = Query)
    FString UserDescription;
 
    FString AutoDescription;
 
    UPROPERTY(EditDefaultsOnly, Instanced, Category = Query)
    TObjectPtr<class UEditableGameplayTagQueryExpression> RootExpression;
 
#if WITH_EDITOR
    GAMEPLAYTAGS_API void EmitTokens(TArray<uint8>& TokenStream, TArray<FGameplayTag>& TagDictionary, FString* DebugString=nullptr) const;
 
    GAMEPLAYTAGS_API FString GetTagQueryExportText(FGameplayTagQuery const& TagQuery);
#endif  // WITH_EDITOR
 
private:
    UPROPERTY()
    FGameplayTagQuery TagQueryExportText_Helper;
};
 
UCLASS(abstract, editinlinenew, collapseCategories, Transient, MinimalAPI)
class UEditableGameplayTagQueryExpression : public UObject
{
    GENERATED_BODY()
 
#if WITH_EDITOR
public:
    virtual void EmitTokens(TArray<uint8>& TokenStream, TArray<FGameplayTag>& TagDictionary, FString* DebugString=nullptr) const {};
 
protected:
    GAMEPLAYTAGS_API void EmitTagTokens(FGameplayTagContainer const& TagsToEmit, TArray<uint8>& TokenStream, TArray<FGameplayTag>& TagDictionary, FString* DebugString) const;
    GAMEPLAYTAGS_API void EmitExprListTokens(TArray<UEditableGameplayTagQueryExpression*> const& ExprList, TArray<uint8>& TokenStream, TArray<FGameplayTag>& TagDictionary, FString* DebugString) const;
#endif  // WITH_EDITOR
};
 
UCLASS(BlueprintType, editinlinenew, collapseCategories, meta=(DisplayName="Any Tags Match"))
class UEditableGameplayTagQueryExpression_AnyTagsMatch : public UEditableGameplayTagQueryExpression
{
    GENERATED_BODY()
public:
    UPROPERTY(EditDefaultsOnly, Category = Expr)
    FGameplayTagContainer Tags;
 
#if WITH_EDITOR
    virtual void EmitTokens(TArray<uint8>& TokenStream, TArray<FGameplayTag>& TagDictionary, FString* DebugString = nullptr) const override;
#endif  // WITH_EDITOR
};
 
UCLASS(BlueprintType, editinlinenew, collapseCategories, meta = (DisplayName = "All Tags Match"))
class UEditableGameplayTagQueryExpression_AllTagsMatch : public UEditableGameplayTagQueryExpression
{
    GENERATED_BODY()
public:
    UPROPERTY(EditDefaultsOnly, Category = Expr)
    FGameplayTagContainer Tags;
 
#if WITH_EDITOR
    virtual void EmitTokens(TArray<uint8>& TokenStream, TArray<FGameplayTag>& TagDictionary, FString* DebugString = nullptr) const override;
#endif  // WITH_EDITOR
};
 
UCLASS(BlueprintType, editinlinenew, collapseCategories, meta = (DisplayName = "No Tags Match"))
class UEditableGameplayTagQueryExpression_NoTagsMatch : public UEditableGameplayTagQueryExpression
{
    GENERATED_BODY()
public:
    UPROPERTY(EditDefaultsOnly, Category = Expr)
    FGameplayTagContainer Tags;
 
#if WITH_EDITOR
    virtual void EmitTokens(TArray<uint8>& TokenStream, TArray<FGameplayTag>& TagDictionary, FString* DebugString = nullptr) const override;
#endif  // WITH_EDITOR
};
 
UCLASS(BlueprintType, editinlinenew, collapseCategories, meta = (DisplayName = "Any Tags Exact Match"))
class UEditableGameplayTagQueryExpression_AnyTagsExactMatch : public UEditableGameplayTagQueryExpression
{
    GENERATED_BODY()
public:
    UPROPERTY(EditDefaultsOnly, Category = Expr)
    FGameplayTagContainer Tags;
 
#if WITH_EDITOR
    virtual void EmitTokens(TArray<uint8>& TokenStream, TArray<FGameplayTag>& TagDictionary, FString* DebugString = nullptr) const override;
#endif  // WITH_EDITOR
};
 
UCLASS(BlueprintType, editinlinenew, collapseCategories, meta = (DisplayName = "All Tags Exact Match"))
class UEditableGameplayTagQueryExpression_AllTagsExactMatch : public UEditableGameplayTagQueryExpression
{
    GENERATED_BODY()
public:
    UPROPERTY(EditDefaultsOnly, Category = Expr)
    FGameplayTagContainer Tags;
 
#if WITH_EDITOR
    virtual void EmitTokens(TArray<uint8>& TokenStream, TArray<FGameplayTag>& TagDictionary, FString* DebugString = nullptr) const override;
#endif  // WITH_EDITOR
};
 
UCLASS(BlueprintType, editinlinenew, collapseCategories, meta = (DisplayName = "Any Expressions Match"))
class UEditableGameplayTagQueryExpression_AnyExprMatch : public UEditableGameplayTagQueryExpression
{
    GENERATED_BODY()
public:
    UPROPERTY(EditAnywhere, Instanced, Category = Expr)
    TArray<TObjectPtr<UEditableGameplayTagQueryExpression>> Expressions;
 
#if WITH_EDITOR
    virtual void EmitTokens(TArray<uint8>& TokenStream, TArray<FGameplayTag>& TagDictionary, FString* DebugString = nullptr) const override;
#endif  // WITH_EDITOR
};
 
UCLASS(BlueprintType, editinlinenew, collapseCategories, meta = (DisplayName = "All Expressions Match"))
class UEditableGameplayTagQueryExpression_AllExprMatch : public UEditableGameplayTagQueryExpression
{
    GENERATED_BODY()
public:
    UPROPERTY(EditAnywhere, Instanced, Category = Expr)
    TArray<TObjectPtr<UEditableGameplayTagQueryExpression>> Expressions;
 
#if WITH_EDITOR
    virtual void EmitTokens(TArray<uint8>& TokenStream, TArray<FGameplayTag>& TagDictionary, FString* DebugString = nullptr) const override;
#endif  // WITH_EDITOR
};
 
UCLASS(BlueprintType, editinlinenew, collapseCategories, meta = (DisplayName = "No Expressions Match"))
class UEditableGameplayTagQueryExpression_NoExprMatch : public UEditableGameplayTagQueryExpression
{
    GENERATED_BODY()
public:
    UPROPERTY(EditAnywhere, Instanced, Category = Expr)
    TArray<TObjectPtr<UEditableGameplayTagQueryExpression>> Expressions;
 
#if WITH_EDITOR
    virtual void EmitTokens(TArray<uint8>& TokenStream, TArray<FGameplayTag>& TagDictionary, FString* DebugString = nullptr) const override;
#endif  // WITH_EDITOR
};