TextFilter.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "CoreTypes.h"
#include "HAL/PlatformAtomics.h"
#include "Misc/AssertionMacros.h"
#include "Templates/RemoveReference.h"
#include "Containers/Array.h"
#include "Containers/UnrealString.h"
#include "Templates/SharedPointer.h"
#include "Delegates/Delegate.h"
#include "Internationalization/Text.h"
#include "Misc/TextFilterExpressionEvaluator.h"
#include "Misc/IFilter.h"
 
template< typename ItemType >
class TTextFilter : public IFilter< ItemType >, public TSharedFromThis< TTextFilter< ItemType > >
{
public:
 
    DECLARE_DELEGATE_TwoParams( FItemToStringArray, ItemType, OUT TArray< FString >& );
 
    DECLARE_DELEGATE_RetVal_FiveParams( bool, FItemTestComplexExpression, ItemType, const FName& /*InKey*/, const FTextFilterString& /*InValue*/, ETextFilterComparisonOperation /*InComparisonOperation*/, ETextFilterTextComparisonMode /*InTextComparisonMode*/ );
 
    TTextFilter( FItemToStringArray InTransformDelegate )
        : TextFilterExpressionContext( InTransformDelegate, FItemTestComplexExpression() )
        , TextFilterExpressionEvaluator( ETextFilterExpressionEvaluatorMode::BasicString )
    {
        check( InTransformDelegate.IsBound() );
    }
 
    TTextFilter( FItemToStringArray InTransformDelegate, FItemTestComplexExpression InTestComplexExpressionDelegate )
        : TextFilterExpressionContext( InTransformDelegate, InTestComplexExpressionDelegate )
        , TextFilterExpressionEvaluator( ETextFilterExpressionEvaluatorMode::Complex )
    {
        check( InTransformDelegate.IsBound() );
        check( InTestComplexExpressionDelegate.IsBound() );
    }
 
    DECLARE_DERIVED_EVENT(TTextFilter, IFilter<ItemType>::FChangedEvent, FChangedEvent);
    virtual FChangedEvent& OnChanged() override { return ChangedEvent; }
 
    virtual bool PassesFilter( ItemType InItem ) const override
    {
        if (TextFilterExpressionEvaluator.GetFilterType() == ETextFilterExpressionType::Empty)
        {
            return true;
        }
        
        TextFilterExpressionContext.SetItem(&InItem);
        const bool bResult = TextFilterExpressionEvaluator.TestTextFilter(TextFilterExpressionContext);
        TextFilterExpressionContext.ClearItem();
        return bResult;
    }
 
    FText GetRawFilterText() const
    {
        return TextFilterExpressionEvaluator.GetFilterText();
    }
 
    void SetRawFilterText( const FText& InFilterText )
    {
        if (TextFilterExpressionEvaluator.SetFilterText(InFilterText))
        {
            ChangedEvent.Broadcast();
        }
    }
 
    FText GetFilterErrorText() const
    {
        return TextFilterExpressionEvaluator.GetFilterErrorText();
    }
 
private:
 
    class FTextFilterExpressionContext : public ITextFilterExpressionContext
    {
    public:
        typedef typename TRemoveReference<ItemType>::Type* ItemTypePtr;
 
        FTextFilterExpressionContext(const FItemToStringArray& InTransformArrayDelegate, const FItemTestComplexExpression& InTestComplexExpressionDelegate)
            : TransformArrayDelegate(InTransformArrayDelegate)
            , TestComplexExpressionDelegate(InTestComplexExpressionDelegate)
            , ItemPtr(nullptr)
        {
        }
 
        void SetItem(ItemTypePtr InItem)
        {
            ItemPtr = InItem;
            TransformArrayDelegate.Execute(*ItemPtr, ItemBasicStrings);
        }
 
        void ClearItem()
        {
            ItemPtr = nullptr;
            ItemBasicStrings.Reset();
        }
 
        virtual bool TestBasicStringExpression(const FTextFilterString& InValue, const ETextFilterTextComparisonMode InTextComparisonMode) const override
        {
            for (const FString& BasicString : ItemBasicStrings)
            {
                if (TextFilterUtils::TestBasicStringExpression(BasicString, InValue, InTextComparisonMode))
                {
                    return true;
                }
            }
            return false;
        }
 
        virtual bool TestComplexExpression(const FName& InKey, const FTextFilterString& InValue, const ETextFilterComparisonOperation InComparisonOperation, const ETextFilterTextComparisonMode InTextComparisonMode) const override
        {
            if (ItemPtr && TestComplexExpressionDelegate.IsBound())
            {
                return TestComplexExpressionDelegate.Execute(*ItemPtr, InKey, InValue, InComparisonOperation, InTextComparisonMode);
            }
            return false;
        }
 
    private:
        FItemToStringArray TransformArrayDelegate;
 
        FItemTestComplexExpression TestComplexExpressionDelegate;
 
        ItemTypePtr ItemPtr;
 
        TArray<FString> ItemBasicStrings;
    };
 
    mutable FTextFilterExpressionContext TextFilterExpressionContext;
 
    FTextFilterExpressionEvaluator TextFilterExpressionEvaluator;
 
    FChangedEvent ChangedEvent;
};