TextFilterExpressionEvaluator.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "Internationalization/Text.h"
#include "Misc/ExpressionParser.h"
#include "Misc/ExpressionParserTypes.h"
#include "Misc/Optional.h"
#include "Misc/TextFilterUtils.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/NameTypes.h"
 
class FTextToken;
 
enum class ETextFilterExpressionType : uint8
{
    Invalid,
    Empty,
    BasicString,
    Complex,
};
 
enum class ETextFilterExpressionEvaluatorMode : uint8
{
    BasicString,
    Complex,
};
 
class ITextFilterExpressionContext
{
public:
    virtual bool TestBasicStringExpression(const FTextFilterString& InValue, const ETextFilterTextComparisonMode InTextComparisonMode) const = 0;
 
    virtual bool TestComplexExpression(const FName& InKey, const FTextFilterString& InValue, const ETextFilterComparisonOperation InComparisonOperation, const ETextFilterTextComparisonMode InTextComparisonMode) const = 0;
 
protected:
    virtual ~ITextFilterExpressionContext() {}
};
 
// A simple basic string expression context for FString
class FBasicStringFilterExpressionContext : public ITextFilterExpressionContext
{
public:
    explicit FBasicStringFilterExpressionContext(FString&& InTestString)
        : TestString(InTestString)
    {
    }
    explicit FBasicStringFilterExpressionContext(const FString& InTestString)
        : TestString(InTestString)
    {
    }
 
    virtual bool TestBasicStringExpression(const FTextFilterString& InValue, const ETextFilterTextComparisonMode InTextComparisonMode) const override
    {
        return TextFilterUtils::TestBasicStringExpression(TestString, InValue, InTextComparisonMode);
    }
 
    virtual bool TestComplexExpression(const FName& InKey, const FTextFilterString& InValue, const ETextFilterComparisonOperation InComparisonOperation, const ETextFilterTextComparisonMode InTextComparisonMode) const override
    {
        return false;
    }
 
private:
    const FString TestString;
};
 
namespace TextFilterExpressionParser
{
    class FTextToken
    {
    public:
        enum class EInvertResult : uint8
        {
            No,
            Yes,
        };
 
        FTextToken(FTextFilterString InString, ETextFilterTextComparisonMode InTextComparisonMode, const EInvertResult InInvertResult)
            : String(MoveTemp(InString))
            , TextComparisonMode(MoveTemp(InTextComparisonMode))
            , InvertResult(InInvertResult)
        {
        }
 
        FTextToken(const FTextToken& Other)
            : String(Other.String)
            , TextComparisonMode(Other.TextComparisonMode)
            , InvertResult(Other.InvertResult)
        {
        }
 
        FTextToken(FTextToken&& Other)
            : String(MoveTemp(Other.String))
            , TextComparisonMode(Other.TextComparisonMode)
            , InvertResult(Other.InvertResult)
        {
        }
 
        FTextToken& operator=(const FTextToken& Other)
        {
            String = Other.String;
            TextComparisonMode = Other.TextComparisonMode;
            InvertResult = Other.InvertResult;
            return *this;
        }
 
        FTextToken& operator=(FTextToken&& Other)
        {
            String = MoveTemp(Other.String);
            TextComparisonMode = Other.TextComparisonMode;
            InvertResult = Other.InvertResult;
            return *this;
        }
 
        const FTextFilterString& GetString() const
        {
            return String;
        }
 
        bool EvaluateAsBasicStringExpression(const ITextFilterExpressionContext* InContext) const
        {
            if (String.IsEmpty())
            {
                // An empty string is always considered to be true
                return true;
            }
 
            const bool bMatched = InContext->TestBasicStringExpression(String, TextComparisonMode);
            return (InvertResult == EInvertResult::No) ? bMatched : !bMatched;
        }
 
        bool EvaluateAsComplexExpression(const ITextFilterExpressionContext* InContext, const FTextFilterString& InKey, const ETextFilterComparisonOperation InComparisonOperation) const
        {
            const bool bMatched = InContext->TestComplexExpression(InKey.AsName(), String, InComparisonOperation, TextComparisonMode);
            return (InvertResult == EInvertResult::No) ? bMatched : !bMatched;
        }
 
        ETextFilterTextComparisonMode GetTextComparisonMode() const
        {
            return TextComparisonMode;
        }
 
    private:
        FTextFilterString String;
        ETextFilterTextComparisonMode TextComparisonMode;
        EInvertResult InvertResult;
    };
 
    class FFunction
    {
 
    };
} // namespace TextFilterExpressionParser
 
#define DEFINE_TEXT_EXPRESSION_OPERATOR_NODE(TYPE, MONIKER_COUNT, ...)  \
    namespace TextFilterExpressionParser                                \
    {                                                                   \
        struct TYPE                                                     \
        {                                                               \
            static constexpr int32 MonikerCount = MONIKER_COUNT;            \
            static const TCHAR* Monikers[MonikerCount];                 \
        };                                                              \
    }                                                                   \
DEFINE_EXPRESSION_NODE_TYPE(TextFilterExpressionParser::TYPE, __VA_ARGS__)
 
DEFINE_TEXT_EXPRESSION_OPERATOR_NODE(FSubExpressionStart,       1,  0x0E7E1BC9, 0xF0B94D5D, 0x80F44D45, 0x85A082AA)
DEFINE_TEXT_EXPRESSION_OPERATOR_NODE(FSubExpressionEnd,         1,  0x5E10956D, 0x2E17411F, 0xB6469E22, 0xB5E56E6C)
 
DEFINE_TEXT_EXPRESSION_OPERATOR_NODE(FEqual,                    3,  0x32457EFC, 0x4928406F, 0xBD78D943, 0x633797D1)
DEFINE_TEXT_EXPRESSION_OPERATOR_NODE(FNotEqual,                 2,  0x8F445A19, 0xF33443D9, 0x90D6DC85, 0xB0C5D071)
DEFINE_TEXT_EXPRESSION_OPERATOR_NODE(FLess,                     1,  0xB85E222B, 0x47E24E1F, 0xBC5A384D, 0x2FF471E1)
DEFINE_TEXT_EXPRESSION_OPERATOR_NODE(FLessOrEqual,              2,  0x8C0A46B0, 0x8DAA4E2B, 0xA7FE4A23, 0xEF215918)
DEFINE_TEXT_EXPRESSION_OPERATOR_NODE(FGreater,                  1,  0x6A6247F4, 0xFD78467F, 0xA6AC1244, 0x0A31E0A5)
DEFINE_TEXT_EXPRESSION_OPERATOR_NODE(FGreaterOrEqual,           2,  0x09D75C5E, 0xA29A4194, 0x8E8E5278, 0xC84365FD)
 
DEFINE_TEXT_EXPRESSION_OPERATOR_NODE(FOr,                       4,  0xF4778B51, 0xF535414D, 0x9C0EB5F2, 0x2F2B0FD4)
DEFINE_TEXT_EXPRESSION_OPERATOR_NODE(FAnd,                      4,  0x7511397A, 0x02D24DC2, 0x86729800, 0xF454C320)
DEFINE_TEXT_EXPRESSION_OPERATOR_NODE(FNot,                      3,  0x03D78990, 0x41D04E26, 0x8E98AD2F, 0x74667868)
 
DEFINE_EXPRESSION_NODE_TYPE(TextFilterExpressionParser::FTextToken, 0x09E49538, 0x633545E3, 0x84B5644F, 0x1F11628F);
DEFINE_EXPRESSION_NODE_TYPE(TextFilterExpressionParser::FFunction,  0x084E6214, 0x032FFA48, 0x9245ABF1, 0x9E248F1A);
 
#undef DEFINE_TEXT_EXPRESSION_OPERATOR_NODE
 
DECLARE_DELEGATE_RetVal_OneParam(bool, FTokenFunctionHandler, const FTextFilterString&);
 
class FTextFilterExpressionEvaluator
{
public:
    CORE_API FTextFilterExpressionEvaluator(const ETextFilterExpressionEvaluatorMode InMode);
    CORE_API FTextFilterExpressionEvaluator(const FTextFilterExpressionEvaluator& Other);
    CORE_API FTextFilterExpressionEvaluator& operator=(const FTextFilterExpressionEvaluator& Other);
    CORE_API virtual ~FTextFilterExpressionEvaluator();
 
    CORE_API ETextFilterExpressionType GetFilterType() const;
 
    CORE_API FText GetFilterText() const;
 
    CORE_API bool SetFilterText(const FText& InFilterText);
 
    CORE_API FText GetFilterErrorText() const;
 
    CORE_API const TArray<FExpressionToken>& GetFilterExpressionTokens() const;
 
    CORE_API bool TestTextFilter(const ITextFilterExpressionContext& InContext) const;
 
    CORE_API void AddFunctionTokenCallback(FString InFunctionName, FTokenFunctionHandler InCallback);
 
protected:
    CORE_API void SetupGrammar();
 
    CORE_API virtual void ConstructExpressionParser();
 
    CORE_API virtual bool EvaluateCompiledExpression(const ExpressionParser::CompileResultType& InCompiledResult, const ITextFilterExpressionContext& InContext, FText* OutErrorText) const;
 
    ETextFilterExpressionEvaluatorMode ExpressionEvaluatorMode;
 
    ETextFilterExpressionType FilterType;
 
    FText FilterText;
 
    FText FilterErrorText;
 
    TArray<FExpressionToken> ExpressionTokens;
 
    TOptional<ExpressionParser::CompileResultType> CompiledFilter;
 
    TOptional<TextFilterExpressionParser::FTextToken> CompiledFilterSingleBasicStringTextToken;
 
    TMap<FString, FTokenFunctionHandler> TokenFunctionHandlers;
 
    FTokenDefinitions TokenDefinitions;
    FExpressionGrammar Grammar;
    TOperatorJumpTable<ITextFilterExpressionContext> JumpTable;
};