file
namespace    UE::MultiUserServer
function     bool FConcertLogFilter_Size::PassesFilter

		// The filter's default value is to show everything 0 <= x so it will show sync events as well.
		const uint32 ComparisionSizeInBytes = FUnitConversion::Convert(SizeInBytes, DataUnit, EUnit::Bytes);
		switch (FilterMode)
		{
		case ESizeFilterMode::LessThanOrEqual:
			return ComparisionSizeInBytes >= static_cast<uint32>(InItem.Log.CustomPayloadUncompressedByteSize);
		case ESizeFilterMode::BiggerThanOrEqual:
			return ComparisionSizeInBytes <= static_cast<uint32>(InItem.Log.CustomPayloadUncompressedByteSize);
		default:

file
namespace    UE::MultiUserServer
function     void FConcertLogFilter_Size::SetOperator

	void FConcertLogFilter_Size::SetOperator(ESizeFilterMode Operator)
	{
		if (FilterMode != Operator)
		{
			FilterMode = Operator;
			OnChanged().Broadcast();
		}
	}

	void FConcertLogFilter_Size::SetSizeInBytes(uint32 NewSizeInBytes)
	{

file
namespace    UE::MultiUserServer
class        class FConcertLogFilter_Size : public IFilter<const FConcertLogEntry&>
function     ESizeFilterMode GetOperator

		void SetDataUnit(EUnit NewUnit);
	
		ESizeFilterMode GetOperator() const { return FilterMode; }
		uint32 GetSizeInBytes() const { return SizeInBytes; }
		EUnit GetDataUnit() const { return DataUnit; }
		TSet<EUnit> GetAllowedUnits() const { return { EUnit::Bytes, EUnit::Kilobytes, EUnit::Megabytes }; }
	
	private:

		ESizeFilterMode FilterMode = ESizeFilterMode::BiggerThanOrEqual;
		uint32 SizeInBytes = 0;
		EUnit DataUnit = EUnit::Bytes;

		FChangedEvent ChangedEvent;
	};

file
namespace    UE::MultiUserServer
function     FConcertLogFilter_Time::FConcertLogFilter_Time

namespace UE::MultiUserServer
{
	FConcertLogFilter_Time::FConcertLogFilter_Time(ETimeFilter FilterMode)
		: FilterMode(FilterMode)
		// Make the filter allow everything by default
		, Time(MakeResetTime())
	{}

	void FConcertLogFilter_Time::ResetToInfiniteTime()
	{

file
namespace    UE::MultiUserServer
function     FDateTime FConcertLogFilter_Time::MakeResetTime

	FDateTime FConcertLogFilter_Time::MakeResetTime() const
	{
		return FilterMode == ETimeFilter::AllowAfter ? FDateTime() : FDateTime::MaxValue();
	}

	bool FConcertLogFilter_Time::PassesFilter(const FConcertLogEntry& InItem) const
	{
		switch (FilterMode)
		{
		case ETimeFilter::AllowAfter: return InItem.Log.Timestamp >= Time;
		case ETimeFilter::AllowBefore: return InItem.Log.Timestamp <= Time;
		default:
			checkNoEntry();
			return true;

file
namespace    UE::MultiUserServer
function     void FConcertLogFilter_Time::SetFilterMode

	void FConcertLogFilter_Time::SetFilterMode(ETimeFilter InFilterMode)
	{
		if (FilterMode != InFilterMode)
		{
			FilterMode = InFilterMode;
			OnChanged().Broadcast();
		}
	}

	void FConcertLogFilter_Time::SetTime(const FDateTime& InTime)
	{

file
namespace    UE::MultiUserServer
class        class FConcertLogFilter_Time : public IFilter<const FConcertLogEntry&>

	public:

		FConcertLogFilter_Time(ETimeFilter FilterMode);

		void ResetToInfiniteTime();

		//~ Begin FConcertLogFilter Interface
		virtual bool PassesFilter(const FConcertLogEntry& InItem) const override;
		virtual FChangedEvent& OnChanged() override { return ChangedEvent; }
		//~ End FConcertLogFilter Interfac

		ETimeFilter GetFilterMode() const { return FilterMode; }
		FDateTime GetTime() const { return Time; }

		void SetFilterMode(ETimeFilter InFilterMode);
		void SetTime(const FDateTime& InTime);
	
	private:

		ETimeFilter FilterMode;
		FDateTime Time;
		FChangedEvent ChangedEvent;

		FDateTime MakeResetTime() const;
	};

file
function     TArray< UObject* > UDataprepFilterLibrary::FilterBySize

}

TArray< UObject* > UDataprepFilterLibrary::FilterBySize(const TArray< UObject* >& TargetArray, EDataprepSizeSource SizeSource, EDataprepSizeFilterMode FilterMode, float Threshold)
{
	TArray< UObject* > Result;

	auto ConditionnalAdd = [=, &Result](float RefValue, UObject* Object) -> void
	{
		if ( (RefValue <= Threshold && FilterMode == EDataprepSizeFilterMode::SmallerThan)
		  || (RefValue >= Threshold && FilterMode == EDataprepSizeFilterMode::BiggerThan) )
		{
			Result.Add(Object);
		}
	};

	switch (SizeSource)

file
class        class UDataprepFilterLibrary : public UBlueprintFunctionLibrary

	 * @param	TargetArray       Array of Actors or StaticMeshes to filter. The array will not change.
	 * @param   SizeSource        The reference dimension
	 * @param   FilterMode        How to compare the object size with the threshold
	 * @param   Threshold         Limit value
	 * @return	The filtered list.
	 */
	UFUNCTION(BlueprintPure, Category = "Dataprep | Filter", meta = (DeterminesOutputType = "TargetArray"))
	static TArray< UObject* > FilterBySize( const TArray< UObject* >& TargetArray, EDataprepSizeSource SizeSource, EDataprepSizeFilterMode FilterMode, float Threshold);

	/**
	 * Filter the array based on a tag.
	 * @param	TargetArray		Array of Actors to filter. The array will not change.
	 * @param	Tag				The tag to filter with.
	 * @return	The filtered list.
	 */
	UFUNCTION(BlueprintPure, Category = "Dataprep | Filter", meta = (DeterminesOutputType = "TargetArray"))

file
function     FAvaOutlinerItemTypeFilterData::FAvaOutlinerItemTypeFilterData

		, EClassFlags InRestrictedClassFlags)
	: FilterClasses(InFilterClasses)
	, FilterMode(InMode)
	, TooltipText(InTooltipText)
	, bUseOverrideIcon(false)
	, IconBrush(InIconBrush)
	, RequiredClassFlags(InRequiredClassFlags)
	, RestrictedClassFlags(InRestrictedClassFlags)
{

file
function     EAvaOutlinerTypeFilterMode FAvaOutlinerItemTypeFilterData::GetFilterMode

EAvaOutlinerTypeFilterMode FAvaOutlinerItemTypeFilterData::GetFilterMode() const
{
	return FilterMode;
}

void FAvaOutlinerItemTypeFilterData::SetOverrideIconColor(FSlateColor InNewIconColor)
{
	OverrideIcon.TintColor = InNewIconColor;
}

file
function     bool FAvaOutlinerItemTypeFilter::PassesFilter

	};

	const EAvaOutlinerTypeFilterMode FilterMode = FilterData.GetFilterMode();

	if (EnumHasAnyFlags(FilterMode, EAvaOutlinerTypeFilterMode::MatchesType))
	{
		if (ItemPassesFilter(InItem))
		{
			return true;
		}
	}

	if (EnumHasAnyFlags(FilterMode, EAvaOutlinerTypeFilterMode::ContainerOfType))
	{
		TArray<FAvaOutlinerItemPtr> RemainingItems = InItem.GetChildren();

		while (!RemainingItems.IsEmpty())
		{
			FAvaOutlinerItemPtr Item = RemainingItems.Pop();

	UPROPERTY(EditAnywhere, Category = "Filter")
	EAvaOutlinerTypeFilterMode FilterMode = EAvaOutlinerTypeFilterMode::MatchesType;

	UPROPERTY(EditAnywhere, Category = "Filter|Advanced")
	FText FilterText;

	UPROPERTY(EditAnywhere, Category = "Filter")
	FText TooltipText;

file
function     void UNiagaraDataInterfaceSkeletalMesh::RandomFilteredVertex

	FSkeletalMeshAccessorHelper MeshAccessor;
	MeshAccessor.Init<FilterMode, TIntegralConstant<ENDISkelMesh_AreaWeightingMode, ENDISkelMesh_AreaWeightingMode::None>>(InstData);

	if (MeshAccessor.IsLODAccessible())
	{
		for (int32 i = 0; i < Context.GetNumInstances(); ++i)
		{
			RandHelper.GetAndAdvance();

file
function     void UNiagaraStackObject::Initialize

	OwningNiagaraNode = InOwningNiagaraNode;
	bIsRefreshingDataInterfaceErrors = false;
	FilterMode = EDetailNodeFilterMode::FilterRootNodesOnly;

	MessageLogGuid = GetSystemViewModel()->GetMessageLogGuid();

	FNiagaraMessageManager::Get()->SubscribeToAssetMessagesByObject(
		FText::FromString("StackObject")
		, MessageLogGuid

file
function     void UNiagaraStackObject::SetOnFilterDetailNodes

{
	OnFilterDetailNodesDelegate = InOnFilterDetailNodes;
	FilterMode = InFilterMode;
}

void UNiagaraStackObject::RegisterInstancedCustomPropertyLayout(UStruct* Class, FOnGetDetailCustomizationInstance DetailLayoutDelegate)
{
	checkf(PropertyRowGenerator.IsValid() == false, TEXT("Can not add additional customizations after children have been refreshed."));
	RegisteredClassCustomizations.Add({ Class, DetailLayoutDelegate });

file
function     void UNiagaraStackObject::RefreshChildrenInternal

				ChildRow->Initialize(CreateDefaultChildRequiredData(), RootTreeNode, bIsTopLevel, bHideTopLevelCategories, GetOwnerStackItemEditorDataKey(), GetOwnerStackItemEditorDataKey(), OwningNiagaraNode);
				ChildRow->SetOwnerGuid(ObjectGuid);
				if (OnFilterDetailNodesDelegate.IsBound() && FilterMode == EDetailNodeFilterMode::FilterAllNodes)
				{
					ChildRow->SetOnFilterDetailNodes(OnFilterDetailNodesDelegate);
				}
			}

			NewChildren.Add(ChildRow);

file
function     FText FNiagaraAssetBrowserMainFilter::GetDisplayName

FText FNiagaraAssetBrowserMainFilter::GetDisplayName() const
{
	if(FilterMode == EFilterMode::All)
	{
		return LOCTEXT("NiagaraMainFilterLabel_All", "All");
	}
	else if(FilterMode == EFilterMode::NiagaraAssetTag)
	{
		return FText::FromString(AssetTagDefinition.AssetTag.ToString());
	}
	else if(FilterMode == EFilterMode::NiagaraAssetTagDefinitionsAsset)
	{
		return AssetTagDefinitionsAsset->GetDisplayName();
	}
	else if(FilterMode == EFilterMode::Recent)
	{
		return LOCTEXT("NiagaraMainFilterLabel_Recent", "Recent");
	}
	else if(FilterMode == EFilterMode::Custom)
	{
		return CustomDisplayName;
	}

	return FText::FromString("Unknown Name");
}

file
function     FARFilter SNiagaraAssetBrowser::GetCurrentBackendFilter

		for(const TSharedRef<FNiagaraAssetBrowserMainFilter>& MainFilter : MainFilterSelector->GetSelectedItems())
		{
			if(MainFilter->FilterMode == FNiagaraAssetBrowserMainFilter::EFilterMode::NiagaraAssetTag)
			{
				AssetTagSelectorFilter.TagsAndValues.Add(FName(MainFilter->AssetTagDefinition.GetGuidAsString()), TOptional<FString>());
			}
		}

		Filter.Append(AssetTagSelectorFilter);

file
function     bool SNiagaraAssetBrowser::ShouldFilterAsset

	for(const TSharedRef<FNiagaraAssetBrowserMainFilter>& MainFilter : MainFilterSelector->GetSelectedItems())
	{
		if(MainFilter->FilterMode == FNiagaraAssetBrowserMainFilter::EFilterMode::All)
		{
			return false;
		}
		else if(MainFilter->FilterMode == FNiagaraAssetBrowserMainFilter::EFilterMode::Recent)
		{
			return MainFilter->IsAssetRecent(AssetData) == false;
		}
		else if(MainFilter->FilterMode == FNiagaraAssetBrowserMainFilter::EFilterMode::NiagaraAssetTag)
		{
			return MainFilter->DoesAssetHaveTag(AssetData) == false;
		}
		else if(MainFilter->FilterMode == FNiagaraAssetBrowserMainFilter::EFilterMode::NiagaraAssetTagDefinitionsAsset)
		{
			return MainFilter->DoesAssetHaveAnyTagFromTagDefinitionsAsset(AssetData) == false;
		}
		else if(MainFilter->FilterMode == FNiagaraAssetBrowserMainFilter::EFilterMode::Custom)
		{
			return MainFilter->CustomShouldFilterAsset.Execute(AssetData);
		}
	}

	return false;

file
function     void SNiagaraAssetBrowser::PopulateFiltersSlot
lambda-function

	TSharedRef<FNiagaraAssetBrowserMainFilter>* AllFilter = AssetBrowserMainFilters.FindByPredicate([](const TSharedRef<FNiagaraAssetBrowserMainFilter>& MainFilterCandidate)
	{
		return MainFilterCandidate->FilterMode == FNiagaraAssetBrowserMainFilter::EFilterMode::All;
	});
	
	if(AllFilter)
	{
		MainFilterSelector->SetSelection(*AllFilter);
		MainFilterSelector->SetItemExpansion(*AllFilter, true);

// 	];
//
// 	if(MainFilter.FilterMode == FNiagaraAssetBrowserMainFilter::EFilterMode::NiagaraAssetTag)
// 	{
// 		Widget->SetToolTipText(MainFilter.AssetTagDefinition.Description);	
// 	}
// 	
// 	return Widget;
// }

file
function     TSharedRef<ITableRow> SNiagaraAssetBrowser::GenerateWidgetRowForMainFilter

	];
	
	if(MainFilter->FilterMode == FNiagaraAssetBrowserMainFilter::EFilterMode::NiagaraAssetTag)
	{
		Widget->SetToolTipText(MainFilter->AssetTagDefinition.Description);	
	}

	if(MainFilter->FilterMode == FNiagaraAssetBrowserMainFilter::EFilterMode::NiagaraAssetTagDefinitionsAsset)
	{
		Widget->SetToolTipText(MainFilter->AssetTagDefinitionsAsset->GetDescription());	
	}
	
	return SNew(STableRow<TSharedRef<FNiagaraAssetBrowserMainFilter>>, OwningTable)
	[

file
class        class UNiagaraStackObject : public UNiagaraStackItemContent, public FNotifyHook

	};

	NIAGARAEDITOR_API void SetOnFilterDetailNodes(FNiagaraStackObjectShared::FOnFilterDetailNodes InOnFilterDetailNodes, EDetailNodeFilterMode FilterMode = EDetailNodeFilterMode::FilterRootNodesOnly);

	NIAGARAEDITOR_API void RegisterInstancedCustomPropertyLayout(UStruct* Class, FOnGetDetailCustomizationInstance DetailLayoutDelegate);
	NIAGARAEDITOR_API void RegisterInstancedCustomPropertyTypeLayout(FName PropertyTypeName, FOnGetPropertyTypeCustomizationInstance PropertyTypeLayoutDelegate, TSharedPtr<IPropertyTypeIdentifier> Identifier = nullptr);

	NIAGARAEDITOR_API UObject* GetObject() const { return WeakObject.Get(); }
	NIAGARAEDITOR_API TSharedPtr<FStructOnScope> GetDisplayedStruct() const { return DisplayedStruct; }

file
class        class UNiagaraStackObject : public UNiagaraStackItemContent, public FNotifyHook

	UNiagaraNode* OwningNiagaraNode;
	FNiagaraStackObjectShared::FOnFilterDetailNodes OnFilterDetailNodesDelegate;
	EDetailNodeFilterMode FilterMode;
	TArray<FRegisteredClassCustomization> RegisteredClassCustomizations;
	TArray<FRegisteredPropertyCustomization> RegisteredPropertyCustomizations;
	TSharedPtr<IPropertyRowGenerator> PropertyRowGenerator;
	bool bIsRefreshingDataInterfaceErrors;

	/** An optional object guid that can be provided to identify the object this stack entry represents. This can be used for summary view purposes and is also given to the child property rows. */

file
function     FNiagaraAssetBrowserMainFilter

	};

	FNiagaraAssetBrowserMainFilter(EFilterMode InFilterMode) : FilterMode(InFilterMode) {}
	
	EFilterMode FilterMode;
	TArray<TSharedRef<FNiagaraAssetBrowserMainFilter>> ChildFilters;

	// If in mode Asset Tag, this is the tag to filter against
	FNiagaraAssetTagDefinition AssetTagDefinition;
	// If in mode Asset Tag Definitions Asset, this is the asset to filter against (should include all assets that match any tag within the asset)
	TObjectPtr<const UNiagaraAssetTagDefinitions> AssetTagDefinitionsAsset;

file
function     bool operator==

	bool operator==(const FNiagaraAssetBrowserMainFilter& Other) const
	{
		if(FilterMode != Other.FilterMode)
		{
			return false;
		}

		if(FilterMode == EFilterMode::NiagaraAssetTag)
		{
			return AssetTagDefinition == Other.AssetTagDefinition;
		}

		if(FilterMode == EFilterMode::NiagaraAssetTagDefinitionsAsset)
		{
			return AssetTagDefinitionsAsset == Other.AssetTagDefinitionsAsset;
		}

		if(CustomGuid.IsValid())
		{

file
function     bool FPCGDeleteAttributesElement::ExecuteInternal

	const bool bAddAttributesFromParent = (Settings->Operation == EPCGAttributeFilterOperation::DeleteSelectedAttributes);
	const EPCGMetadataFilterMode FilterMode = bAddAttributesFromParent ? EPCGMetadataFilterMode::ExcludeAttributes : EPCGMetadataFilterMode::IncludeAttributes;

	TSet<FName> AttributesToFilter; 
	const TArray<FString> FilterAttributes = PCGHelpers::GetStringArrayFromCommaSeparatedString(Settings->SelectedAttributes);
	for (const FString& FilterAttribute : FilterAttributes)
	{
		AttributesToFilter.Add(FName(*FilterAttribute));

file
function     bool FPCGDeleteAttributesElement::ExecuteInternal

			UPCGSpatialData* NewSpatialData = InputSpatialData->DuplicateData(/*bInitializeFromThisData=*/false);
			Metadata = NewSpatialData->Metadata;
			NewSpatialData->Metadata->InitializeWithAttributeFilter(ParentMetadata, AttributesToFilter, FilterMode);

			// No need to inherit metadata since we already initialized it.
			NewSpatialData->InitializeFromData(InputSpatialData, /*InMetadataParentOverride=*/ nullptr, /*bInheritMetadata=*/ false);

			OutputData = NewSpatialData;
		}

file
function     bool FPCGDeleteAttributesElement::ExecuteInternal

			UPCGParamData* NewParamData = NewObject<UPCGParamData>();
			Metadata = NewParamData->Metadata;
			Metadata->InitializeAsCopyWithAttributeFilter(ParentMetadata, AttributesToFilter, FilterMode);

			OutputData = NewParamData;
		}
		else
		{
			PCGE_LOG(Error, GraphAndLog, LOCTEXT("InvalidInputData", "Invalid data as input. Only Spatial and Attribute Set data are supported."));

file
function     TSharedRef<SWidget> SNetStatsCountersView::TreeViewHeaderRow_GenerateColumnMenu

		//if (Column.CanBeFiltered())
		//{
		//	MenuBuilder.BeginSection("FilterMode", LOCTEXT("ContextMenu_Header_Misc_Filter_FilterMode", "Filter Mode"));
		//	bIsMenuVisible = true;
		//	MenuBuilder.EndSection();
		//}
	}

	/*

 * 
 * [Core.VirtualizationModule]
 * FilterMode=OptIn/OptOut					The general mode to be applied to all packages. With 'OptIn' packages will
 *											not be virtualized unless their path is included via VirtualizationFilterSettings.
 *											With 'OptOut' all packages will be virtualized unless excluded via 
 *											VirtualizationFilterSettings [Default=OptOut]
 * FilterMapContent=True/False				When true any payload stored in a .umap or _BuildData.uasset file will be
 *											excluded from virtualization [Default=true]
 * 
 * PackagePath Setup:
 * 
 * In addition to the default filtering mode set above, payloads stored in packages can be filtered based on the
 * package path. This allows a package to be including in the virtualization process or excluded from it.
 * 
 * Note that these paths will be stored in the ini files under the Saved directory. To remove a path make sure to 
 * use the - syntax to remove the entry from the array, rather than removing the line itself. Otherwise it will
 * persist until the saved config file has been reset.
 *
 * [/Script/Virtualization.VirtualizationFilterSettings]
 * +ExcludePackagePaths="/MountPoint/PathToExclude/"				Excludes any package found under '/MountPoint/PathToExclude/' from the virtualization process
 * +ExcludePackagePaths="/MountPoint/PathTo/ThePackageToExclude"	Excludes the specific package '/MountPoint/PathTo/ThePackageToExclude' from the virtualization process
 * +IncludePackagePaths="/MountPoint/PathToInclude/"				Includes any package found under '/MountPoint/PathToInclude/' in the virtualization process
 * +IncludePackagePaths="/MountPoint/PathTo/ThePackageToInclude"	Includes the specific package '/MountPoint/PathTo/ThePackageToInclude' in the virtualization process
 */

/*
 * FVirtualizationManager
 * 
 * Ini file setup:
 * 
 * EnablePayloadVirtualization [bool]:			When true the virtualization process will be enabled (usually when a package is submitted
												to revision control. [Default=true]
 * EnableCacheOnPull [bool]:					When true payloads will be pushed to cached storage after being pulled from persistent
 *												storage. [Default=true]
 * EnableCacheOnPush [bool]:					When true payloads will be pushed to cached storage right before being pushed to persistent
 *												storage. [Default=true]
 * MinPayloadLength  [int64]:					The minimum length (in bytes) that a payload must reach before it can be considered for
 *												virtualization. Use this to strike a balance between disk space and the number of smaller
												payloads in your project being virtualized. [Default=0]
 * BackendGraph [string]:						The name of the backend graph to use. The default graph has no backends and effectively
												disables the system. It is expected that a project will define the graph that it wants
												and then set this option [Default=ContentVirtualizationBackendGraph_None]
 * VirtualizationProcessTag [string]:			The tag to be applied to any set of packages that have had  the virtualization process run
 *												on them. Typically this means appending the tag to the description of a changelist of 
 *												packages. This value can be set to an empty string. [Default="#virtualized"]
 * AllowSubmitIfVirtualizationFailed [bool]:	Revision control submits that trigger the virtualization system can either allow or block
 *												the submit if the virtualization process fails based on this value. True will allow a
 *												submit with an error to continue and false will block the submit. Note that by error we mean

file
namespace    UE::Virtualization
class        class FVirtualizationManager final : public IVirtualizationSystem

	 * that might have been set in UVirtualizationFilterSettings.
	 * If the path does not match any pattern set in UVirtualizationFilterSettings then use the default 
	 * FilterMode to determine if the payload should be virtualized or not.
	 * 
	 * @param PackagePath	The path of the package to check. This can be empty which would indicate that
	 *						a payload is not owned by a specific package.
	 * @return				True if the package should be virtualized and false if the package path is 
	 *						excluded by the projects current filter set up.
	 */
	bool ShouldVirtualizePackage(const FPackagePath& PackagePath) const;

	/**
	 * Determines if a package should be virtualized or not based on the given content.
	 * If the context can be turned into a package path then ::ShouldVirtualizePackage 
	 * will be used instead.
	 * If the context is not a package path then we use the default FilterMode to determine
	 * if the payload should be virtualized or not.
	 * 
	 * @return True if the context should be virtualized and false if not.
	 */
	bool ShouldVirtualize(const FString& Context) const;

	/** Determines if the default filtering behavior is to virtualize a payload or not */
	bool ShouldVirtualizeAsDefault() const;

	/** Returns if the process will attempt to retry a failed pull when the process is unattended mode */
	bool ShouldRetryWhenUnattended() const;

	void BroadcastEvent(TConstArrayView<FPullRequest> Ids, ENotification Event);
	

file
class        class UEdGraphSchema_K2 : public UEdGraphSchema

	/** Can this variable be accessed by kismet code */
	static bool CanUserKismetAccessVariable(const FProperty* Property, const UClass* InClass, EDelegateFilterMode FilterMode);

	/** Can this function be overridden by kismet (either placed as event or new function graph created) */
	static bool CanKismetOverrideFunction(const UFunction* Function);

	/** returns friendly signature name if possible or Removes any mangling to get the unmangled signature name of the function */
	static FText GetFriendlySignatureName(const UFunction* Function);

file
function     bool UEdGraphSchema_K2::CanUserKismetAccessVariable

bool UEdGraphSchema_K2::CanUserKismetAccessVariable(const FProperty* Property, const UClass* InClass, EDelegateFilterMode FilterMode)
{
	const bool bIsDelegate = Property->IsA(FMulticastDelegateProperty::StaticClass());
	const bool bIsAccessible = Property->HasAllPropertyFlags(CPF_BlueprintVisible);
	const bool bIsAssignableOrCallable = Property->HasAnyPropertyFlags(CPF_BlueprintAssignable | CPF_BlueprintCallable);
	
	const bool bPassesDelegateFilter = (bIsAccessible && !bIsDelegate && (FilterMode != MustBeDelegate)) || 
		(bIsAssignableOrCallable && bIsDelegate && (FilterMode != CannotBeDelegate));

	const bool bHidden = FObjectEditorUtils::IsVariableCategoryHiddenFromClass(Property, InClass);

	return !Property->HasAnyPropertyFlags(CPF_Parm) && bPassesDelegateFilter && !bHidden;
}

file
function     void FWorldPartitionActorFilterHierarchy::CreateItems

void FWorldPartitionActorFilterHierarchy::CreateItems(TArray<FSceneOutlinerTreeItemPtr>& OutItems) const
{
	FWorldPartitionActorFilterMode* FilterMode = static_cast<FWorldPartitionActorFilterMode*>(Mode);
	check(FilterMode);
	const FWorldPartitionActorFilter* Filter = FilterMode->GetFilter();
	check(Filter);
	if (FSceneOutlinerTreeItemPtr FilterTreeItem = Mode->CreateItemFor<FWorldPartitionActorFilterItem>(FWorldPartitionActorFilterItem::FTreeItemData(Filter), true))
	{
		OutItems.Add(FilterTreeItem);
		CreateChildren(FilterTreeItem, OutItems, true);
	}

file
namespace    UE::AssetRegistry::Utils
function     bool RunAssetThroughFilter

{

bool RunAssetThroughFilter(const FAssetData& AssetData, const FARCompiledFilter& Filter, const EFilterMode FilterMode)
{
	const bool bPassFilterValue = FilterMode == EFilterMode::Inclusive;
	if (Filter.IsEmpty())
	{
		return bPassFilterValue;
	}

	const bool bFilterResult = RunAssetThroughFilter_Unchecked(AssetData, Filter, bPassFilterValue);

file
namespace    UE::AssetRegistry::Utils
function     void RunAssetsThroughFilter

}

void RunAssetsThroughFilter(TArray<FAssetData>& AssetDataList, const FARCompiledFilter& CompiledFilter, const EFilterMode FilterMode)
{
	if (!IsFilterValid(CompiledFilter))
	{
		return;
	}

	const int32 OriginalArrayCount = AssetDataList.Num();
	const bool bPassFilterValue = FilterMode == EFilterMode::Inclusive;

	AssetDataList.RemoveAll([&CompiledFilter, bPassFilterValue](const FAssetData& AssetData)
		{
			const bool bFilterResult = RunAssetThroughFilter_Unchecked(AssetData, CompiledFilter, bPassFilterValue);
			return bFilterResult != bPassFilterValue;
		});

file
namespace    UE::AssetRegistry
namespace    Utils

bool IsFilterValid(const FARCompiledFilter& Filter);
/** Report whether the given AssetData passes/fails the given filter */
bool RunAssetThroughFilter(const FAssetData& AssetData, const FARCompiledFilter& Filter, const EFilterMode FilterMode);
/** Helper for RunAssetThroughFilter and RunAssetsThroughFilter that skips validity check */
bool RunAssetThroughFilter_Unchecked(const FAssetData& AssetData, const FARCompiledFilter& Filter, const bool bPassFilterValue);
/**
 * Given an array of asset data, trim the items that fail the filter based on the inclusion/exclusion mode used.
 *  - In inclusive mode it will remove all assets that fail the filter, and in exclusive mode it will remove all assets that pass the filter.
 *  - If the filter is empty, then the array will be untouched.
 */
void RunAssetsThroughFilter(TArray<FAssetData>& AssetDataList, const FARCompiledFilter& Filter, const EFilterMode FilterMode);

/** This will always read the ini, public version may return cache */
void InitializeSerializationOptionsFromIni(FAssetRegistrySerializationOptions& Options, const FString& PlatformIniName,
	ESerializationTarget Target = ESerializationTarget::ForGame);

/** Gets the current availability of an asset, primarily for streaming install purposes. */

file
function     void FBoneContainer::CacheRequiredAnimCurves

	CurveFilter.Empty();
	CurveFilter.SetFilterMode(InCurveFilterSettings.FilterMode);

	CurveFlags.Empty();

	if (USkeleton* Skeleton = AssetSkeleton.GetEvenIfUnreachable())
	{
		// Copy filter curves.

file
function     void FBoneContainer::CacheRequiredAnimCurves

		}
		
		if (InCurveFilterSettings.FilterMode != UE::Anim::ECurveFilterMode::DisallowAll)
		{
			// Apply curve metadata, LOD and linked bones filtering
			Skeleton->ForEachCurveMetaData([this, &InCurveFilterSettings, &FilterCurves](const FName& InCurveName, const FCurveMetaData& InMetaData)
			{
				bool bBeingUsed = true;
				UE::Anim::ECurveElementFlags Flags = UE::Anim::ECurveElementFlags::None;

file
function     UE::Anim::FCurveFilterSettings USkeletalMeshComponent::GetCurveFilterSettings

		if(FilteredAnimCurves.Num() > 0)
		{
			CurveFilterSettings.FilterMode = bFilteredAnimCurvesIsAllowList ? UE::Anim::ECurveFilterMode::AllowOnlyFiltered : UE::Anim::ECurveFilterMode::DisallowFiltered;
			CurveFilterSettings.FilterCurves = &FilteredAnimCurves;
		}
		else
		{
			CurveFilterSettings.FilterMode = UE::Anim::ECurveFilterMode::DisallowFiltered;	// This applies LOD-based and bone-linked filtering
		}
	}
	else
	{
		CurveFilterSettings.FilterMode = UE::Anim::ECurveFilterMode::DisallowAll;
	}

	if(InLODOverride != INDEX_NONE)
	{
		CurveFilterSettings.LODIndex = InLODOverride;
	}

file
namespace    UE::Anim

	// Curve is explicitly disallowed (i.e. not processed at a particular LOD, bone linkage etc.).
	// This is used in combination with the FilterMode of the filter.
	Disallowed	= 0x01,

	// Curve is allowed/disallowed.
	// This is used in combination with the FilterMode of the filter for allow/deny lists of curves.
	Filtered	= 0x02,
};

ENUM_CLASS_FLAGS(ECurveFilterFlags);

// The various ways curves can be filtered

file
namespace    UE::Anim
function     void Empty

	{
		Super::Empty();
		FilterMode = ECurveFilterMode::None;
	}

	bool IsEmpty() const
	{
		return FilterMode == ECurveFilterMode::None || (FilterMode == ECurveFilterMode::DisallowFiltered && Elements.Num() == 0);
	}

	void Add(FName InName, ECurveFilterFlags InFlags = ECurveFilterFlags::Filtered)
	{
		Elements.Emplace(InName, InFlags);
		bSorted = false;

file
namespace    UE::Anim
function     void SetFilterMode

	void SetFilterMode(ECurveFilterMode InFilterMode)
	{
		FilterMode = InFilterMode;
	}

private:
	// The filtering mode
	ECurveFilterMode FilterMode = ECurveFilterMode::None;
};

}

file
namespace    UE::Anim
function     static void BuildSortedFiltered

	{
		// Early out if we are filtering all curves
		if(InFilter.FilterMode == ECurveFilterMode::DisallowAll)
		{
			OutCurve.Empty();
			return;
		}

		InFilter.SortElementsIfRequired();

file
namespace    UE::Anim
function     static void BuildSortedFiltered

				for( ; ElementIndex0 < NumElements0; ++ElementIndex0)
				{
					if(ElementPassesFilter(InFilter.FilterMode, ECurveFilterFlags::None))
					{
						OutCurve.Elements.Emplace(InNamePredicate(ElementIndex0), InValuePredicate(ElementIndex0));
					}
				}
				break;
			}

file
namespace    UE::Anim
function     static void BuildSortedFiltered

			{
				// Elements match, check filter & write to curve
				if(ElementPassesFilter(InFilter.FilterMode, Element1->Flags))
				{
					OutCurve.Elements.Emplace(CurveName, InValuePredicate(ElementIndex0));
				}

				++ElementIndex0;
				++ElementIndex1;

file
namespace    UE::Anim
function     static void BuildSortedFiltered

			{
				// Element exists only in user data
				if(ElementPassesFilter(InFilter.FilterMode, ECurveFilterFlags::None))
				{
					OutCurve.Elements.Emplace(CurveName, InValuePredicate(ElementIndex0));
				}
				
				++ElementIndex0;
			}

file
namespace    UE::Anim
function     static void Filter

		CURVE_PROFILE_CYCLE_COUNTER(FCurveUtils_Filter);
		
		switch(InFilter.FilterMode)
		{
		case ECurveFilterMode::None:
			// No filtering, early out
			return;
		case ECurveFilterMode::DisallowAll:
			// Filtering all curves, so just clear curve

file
function     static void Filter

				while(ElementIndex0 < NumElements0)
				{
					if(!ElementPassesFilter(InFilter.FilterMode, ECurveFilterFlags::None))
					{
						InOutCurve.Elements.RemoveAt(ElementIndex0, 1, EAllowShrinking::No);
						NumElements0 = InOutCurve.Num();
					}
					else
					{

file
namespace    UE::Anim
function     static void Filter

			{
				// Elements match so check filter flags to see if it should be removed from curve
				if(!ElementPassesFilter(InFilter.FilterMode, Element1->Flags))
				{
					InOutCurve.Elements.RemoveAt(ElementIndex0, 1, EAllowShrinking::No);
					NumElements0 = InOutCurve.Num();
					++ElementIndex1;
				}
				else

file
namespace    UE::Anim
function     static void Filter

			{
				// Element exists only in curve, check filter
				if(!ElementPassesFilter(InFilter.FilterMode, ECurveFilterFlags::None))
				{
					InOutCurve.Elements.RemoveAt(ElementIndex0, 1, EAllowShrinking::No);
					NumElements0 = InOutCurve.Num();
				}
				else
				{

file
namespace    UE::Anim
function     FCurveFilterSettings

	FCurveFilterSettings(UE::Anim::ECurveFilterMode InFilterMode = UE::Anim::ECurveFilterMode::DisallowFiltered, const TArray<FName>* InFilterCurves = nullptr, int32 InLODIndex = 0)
		: FilterCurves(InFilterCurves)
		, FilterMode(InFilterMode)
		, LODIndex(InLODIndex)
	{}

	// Filter curves. Application of these curves is dependent on FilterMode
	const TArray<FName>* FilterCurves = nullptr;
	
	// Filtering mode - allows curves to be disable entirely or allow/deny-listed
	UE::Anim::ECurveFilterMode FilterMode = UE::Anim::ECurveFilterMode::DisallowFiltered;

	// LOD index
	int32 LODIndex = 0;
};

}