SortMethod

SortMethod

#Overview

name: SortMethod

The value of this variable can be defined or overridden in .ini config files. 1 .ini config file referencing this setting variable.

It is referenced in 56 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of SortMethod is to determine how certain data elements or events are ordered within Unreal Engine subsystems. It is used in various contexts across different modules to specify the sorting criteria for collections of data.

SortMethod is primarily utilized in the following Unreal Engine subsystems, plugins, or modules:

  1. Online Subsystem: Used for sorting leaderboard entries.
  2. Content Browser: Applied to sort asset items in the editor.
  3. Geometry Collection Engine: Employed to sort various Chaos physics events (collision, breaking, trailing, and removal events).
  4. Blueprint Header View: Used to sort functions and properties in blueprint headers.
  5. PCG (Procedural Content Generation): Applied to sort attributes in PCG elements.

The value of this variable is typically set through configuration settings, often using UPROPERTY macros to expose it in the Unreal Editor. For example, in the BlueprintHeaderViewSettings, it’s set as a config property:

UPROPERTY(config, EditAnywhere, Category="Settings")
EHeaderViewSortMethod SortMethod = EHeaderViewSortMethod::None;

SortMethod often interacts with other variables related to the specific context it’s used in. For example, in leaderboard systems, it works alongside variables like DisplayFormat and UpdateMethod.

Developers should be aware that:

  1. The sorting method can significantly impact performance, especially for large datasets.
  2. Different sorting methods may be more appropriate for different types of data or use cases.
  3. The chosen sort method may affect how data is displayed or processed in the engine or game.

Best practices when using this variable include:

  1. Choose the most appropriate sort method for your specific use case.
  2. Consider performance implications, especially for large datasets.
  3. Ensure that the chosen sort method aligns with the expectations of your users or gameplay requirements.
  4. When exposing sort options to end-users, provide clear descriptions of what each option does.
  5. Test thoroughly with various datasets to ensure the sorting behaves as expected in all scenarios.

#Setting Variables

#References In INI files

Location: <Workspace>/Engine/Config/BaseEditorPerProjectUserSettings.ini:993, section: [/Script/BlueprintHeaderView.BlueprintHeaderViewSettings]

#References in C++ code

#Callsites

This variable is referenced in the following C++ source code:

#Loc: <Workspace>/Engine/Plugins/Editor/BlueprintHeaderView/Source/BlueprintHeaderView/Private/SBlueprintHeaderView.cpp:566

Scope (from outer to inner):

file
function     void SBlueprintHeaderView::GatherFunctionGraphs

Source code excerpt:


	const UBlueprintHeaderViewSettings* BlueprintHeaderViewSettings = GetDefault<UBlueprintHeaderViewSettings>();
	if (BlueprintHeaderViewSettings->SortMethod == EHeaderViewSortMethod::SortByAccessSpecifier)
	{
		OutFunctionGraphs.Sort([](const UEdGraph& LeftGraph, const UEdGraph& RightGraph)
			{
				TArray<UK2Node_FunctionEntry*> LeftEntryNodes;
				LeftGraph.GetNodesOfClass<UK2Node_FunctionEntry>(LeftEntryNodes);
				TArray<UK2Node_FunctionEntry*> RightEntryNodes;

#Loc: <Workspace>/Engine/Plugins/Editor/BlueprintHeaderView/Source/BlueprintHeaderView/Private/SBlueprintHeaderView.cpp:593

Scope (from outer to inner):

file
function     void SBlueprintHeaderView::AddVariableItems

Source code excerpt:


	const UBlueprintHeaderViewSettings* BlueprintHeaderViewSettings = GetDefault<UBlueprintHeaderViewSettings>();
	if (BlueprintHeaderViewSettings->SortMethod == EHeaderViewSortMethod::SortByAccessSpecifier)
	{
		VarProperties.Sort([](const FProperty& LeftProp, const FProperty& RightProp)
			{
				return !LeftProp.GetBoolMetaData(FBlueprintMetadata::MD_Private) && RightProp.GetBoolMetaData(FBlueprintMetadata::MD_Private);
			});
	}
	else if (BlueprintHeaderViewSettings->SortMethod == EHeaderViewSortMethod::SortForOptimalPadding)
	{
		SortPropertiesForPadding(VarProperties);
	}

	// We should only add an access specifier line if the previous variable was a different one
	int32 PrevAccessSpecifier = 0;

#Loc: <Workspace>/Engine/Plugins/Editor/BlueprintHeaderView/Source/BlueprintHeaderView/Public/BlueprintHeaderViewSettings.h:82

Scope (from outer to inner):

file
class        class UBlueprintHeaderViewSettings : public UDeveloperSettings

Source code excerpt:

	/** Sorting Method for Header View Functions and Properties */
	UPROPERTY(config, EditAnywhere, Category="Settings")
	EHeaderViewSortMethod SortMethod = EHeaderViewSortMethod::None;
};

#Loc: <Workspace>/Engine/Plugins/Online/OnlineSubsystem/Source/Public/OnlineStats.h:98

Scope (from outer to inner):

file
class        class FOnlineLeaderboardWrite : public FOnlineStats

Source code excerpt:


	/** Sort Method */
	ELeaderboardSort::Type SortMethod;
	/** Display Type */
	ELeaderboardFormat::Type DisplayFormat;
	/** Update Method */
	ELeaderboardUpdateMethod::Type UpdateMethod;

	/** Names of the leaderboards to write to */

#Loc: <Workspace>/Engine/Plugins/Online/OnlineSubsystem/Source/Public/OnlineStats.h:111

Scope (from outer to inner):

file
class        class FOnlineLeaderboardWrite : public FOnlineStats
function     FOnlineLeaderboardWrite

Source code excerpt:


	FOnlineLeaderboardWrite() :
		SortMethod(ELeaderboardSort::None),
		DisplayFormat(ELeaderboardFormat::Number),
		UpdateMethod(ELeaderboardUpdateMethod::KeepBest),
		RatedStat(NAME_None)
	{
	}
};

#Loc: <Workspace>/Engine/Plugins/Online/OnlineSubsystem/Source/Test/OnlineLeaderboard.spec.cpp:393

Scope (from outer to inner):

file
lambda-function
lambda-function
lambda-function
lambda-function

Source code excerpt:

						LeaderboardWriteObject.RatedStat = "TestStat";
						LeaderboardWriteObject.DisplayFormat = ELeaderboardFormat::Number;
						LeaderboardWriteObject.SortMethod = ELeaderboardSort::Descending;
						LeaderboardWriteObject.UpdateMethod = ELeaderboardUpdateMethod::KeepBest;

						LeaderboardWriteObject.SetIntStat("TestStat", 50);

						bool bCallStarted = OnlineLeaderboards->WriteLeaderboards(TEXT("TestSessionName"), *TestAccountId, LeaderboardWriteObject);

#Loc: <Workspace>/Engine/Plugins/Online/OnlineSubsystem/Source/Test/OnlineLeaderboard.spec.cpp:416

Scope (from outer to inner):

file
lambda-function
lambda-function
lambda-function
lambda-function

Source code excerpt:

						LeaderboardWriteObject.RatedStat = "TestStat";
						LeaderboardWriteObject.DisplayFormat = ELeaderboardFormat::Number;
						LeaderboardWriteObject.SortMethod = ELeaderboardSort::Descending;
						LeaderboardWriteObject.UpdateMethod = ELeaderboardUpdateMethod::KeepBest;

						LeaderboardWriteObject.SetIntStat("TestStat", 50);

						OnlineLeaderboards->WriteLeaderboards(TEXT(""), *TestAccountId, LeaderboardWriteObject);

#Loc: <Workspace>/Engine/Plugins/Online/OnlineSubsystem/Source/Test/OnlineLeaderboard.spec.cpp:436

Scope (from outer to inner):

file
lambda-function
lambda-function
lambda-function
lambda-function

Source code excerpt:

						LeaderboardWriteObject.RatedStat = "TestStat";
						LeaderboardWriteObject.DisplayFormat = ELeaderboardFormat::Number;
						LeaderboardWriteObject.SortMethod = ELeaderboardSort::Descending;
						LeaderboardWriteObject.UpdateMethod = ELeaderboardUpdateMethod::KeepBest;

						LeaderboardWriteObject.SetIntStat("TestStat", 50);

						OnlineLeaderboards->WriteLeaderboards(TEXT("TestSessionName"), *TestAccountId, LeaderboardWriteObject);

#Loc: <Workspace>/Engine/Plugins/Online/OnlineSubsystem/Source/Test/OnlineLeaderboard.spec.cpp:480

Scope (from outer to inner):

file
lambda-function
lambda-function
lambda-function
lambda-function

Source code excerpt:

						LeaderboardWriteObject.RatedStat = "TestStat";
						LeaderboardWriteObject.DisplayFormat = ELeaderboardFormat::Number;
						LeaderboardWriteObject.SortMethod = ELeaderboardSort::Descending;
						LeaderboardWriteObject.UpdateMethod = ELeaderboardUpdateMethod::KeepBest;

						LeaderboardWriteObject.SetIntStat("TestStat", 50);

						OnlineLeaderboards->WriteLeaderboards(TEXT("TestSessionName"), *TestAccountId, LeaderboardWriteObject);

#Loc: <Workspace>/Engine/Plugins/Online/OnlineSubsystemNull/Source/Private/OnlineLeaderboardInterfaceNull.cpp:104

Scope (from outer to inner):

file
function     bool FOnlineLeaderboardsNull::WriteLeaderboards

Source code excerpt:

	{
		// Will create or retrieve the leaderboards, triggering async calls as appropriate
		FLeaderboardNull* Leaderboard = FindOrCreateLeaderboard(WriteObject.LeaderboardNames[LeaderboardIdx], WriteObject.SortMethod, WriteObject.DisplayFormat);
		check(Leaderboard);

		FOnlineStatsRow* PlayerRow = Leaderboard->FindOrCreatePlayerRecord(Player);
		check(PlayerRow);

		for (FStatPropertyArray::TConstIterator It(WriteObject.Properties); It; ++It)

#Loc: <Workspace>/Engine/Plugins/Online/OnlineSubsystemNull/Source/Private/OnlineLeaderboardInterfaceNull.cpp:127

Scope (from outer to inner):

file
function     bool FOnlineLeaderboardsNull::WriteLeaderboards

Source code excerpt:

					ExistingStat->GetValue(OldValue);

					switch (WriteObject.SortMethod)
					{
					case ELeaderboardSort::Ascending:
						bJustAssign = NewValue < OldValue;
						break;
					case ELeaderboardSort::Descending:
						bJustAssign = NewValue > OldValue;

#Loc: <Workspace>/Engine/Plugins/Online/OnlineSubsystemNull/Source/Private/OnlineLeaderboardInterfaceNull.cpp:156

Scope (from outer to inner):

file
function     FOnlineLeaderboardsNull::FLeaderboardNull* FOnlineLeaderboardsNull::FindOrCreateLeaderboard

Source code excerpt:

}

FOnlineLeaderboardsNull::FLeaderboardNull* FOnlineLeaderboardsNull::FindOrCreateLeaderboard(const FName& LeaderboardName, ELeaderboardSort::Type SortMethod, ELeaderboardFormat::Type DisplayFormat)
{
	FLeaderboardNull* Existing = Leaderboards.Find(LeaderboardName);
	if (Existing == NULL)
	{
		FLeaderboardNull NewLeaderboard;
		NewLeaderboard.LeaderboardName = LeaderboardName;

#Loc: <Workspace>/Engine/Plugins/Online/OnlineSubsystemNull/Source/Private/OnlineLeaderboardInterfaceNull.h:55

Scope (from outer to inner):

file
class        class FOnlineLeaderboardsNull : public IOnlineLeaderboards

Source code excerpt:

	 * If the leaderboard already exists, the leaderboard data will still be retrieved
	 * @param LeaderboardName name of leaderboard to create
	 * @param SortMethod method the leaderboard scores will be sorted, ignored if leaderboard exists
	 * @param DisplayFormat type of data the leaderboard represents, ignored if leaderboard exists
	 */
	FLeaderboardNull* FindOrCreateLeaderboard(const FName& LeaderboardName, ELeaderboardSort::Type SortMethod, ELeaderboardFormat::Type DisplayFormat);

PACKAGE_SCOPE:

	FOnlineLeaderboardsNull(FOnlineSubsystemNull* InNullSubsystem) :
		NullSubsystem(InNullSubsystem)
	{
	}

public:

#Loc: <Workspace>/Engine/Plugins/Online/OnlineSubsystemSteam/Source/Private/OnlineLeaderboardInterfaceSteam.cpp:594

Scope (from outer to inner):

file
class        class FOnlineAsyncTaskSteamRetrieveLeaderboard : public FOnlineAsyncTaskSteam

Source code excerpt:

	FName LeaderboardName;
	/** Method of sorting the scores on the leaderboard */
	ELeaderboardSort::Type SortMethod;
	/** Method of displaying the data on the leaderboard */
	ELeaderboardFormat::Type DisplayFormat;
	/** Results returned from Steam backend */
	LeaderboardFindResult_t CallbackResults;
	/** Should find only */
	bool bFindOnly;

#Loc: <Workspace>/Engine/Plugins/Online/OnlineSubsystemSteam/Source/Private/OnlineLeaderboardInterfaceSteam.cpp:606

Scope (from outer to inner):

file
class        class FOnlineAsyncTaskSteamRetrieveLeaderboard : public FOnlineAsyncTaskSteam

Source code excerpt:

	 * If the leaderboard already exists, the leaderboard data will still be retrieved
	 * @param LeaderboardName name of leaderboard to create
	 * @param SortMethod method the leaderboard scores will be sorted, ignored if leaderboard exists
	 * @param DisplayFormat type of data the leaderboard represents, ignored if leaderboard exists
	 */
	void CreateOrFindLeaderboard(const FName& InLeaderboardName, ELeaderboardSort::Type InSortMethod, ELeaderboardFormat::Type InDisplayFormat)
	{
		if (bFindOnly)
		{
			CallbackHandle = SteamUserStats()->FindLeaderboard(TCHAR_TO_UTF8(*InLeaderboardName.ToString()));
		}
		else
		{
			ELeaderboardSortMethod SortMethodSteam = ToSteamLeaderboardSortMethod(InSortMethod);
			ELeaderboardDisplayType DisplayTypeSteam = ToSteamLeaderboardDisplayType(InDisplayFormat);

#Loc: <Workspace>/Engine/Plugins/Online/OnlineSubsystemSteam/Source/Private/OnlineLeaderboardInterfaceSteam.cpp:628

Scope (from outer to inner):

file
class        class FOnlineAsyncTaskSteamRetrieveLeaderboard : public FOnlineAsyncTaskSteam
function     FOnlineAsyncTaskSteamRetrieveLeaderboard

Source code excerpt:

		bInit(false),
		LeaderboardName(NAME_None),
		SortMethod(ELeaderboardSort::Ascending),
		DisplayFormat(ELeaderboardFormat::Number),
		bFindOnly(true)
	{
	}

public:

#Loc: <Workspace>/Engine/Plugins/Online/OnlineSubsystemSteam/Source/Private/OnlineLeaderboardInterfaceSteam.cpp:640

Scope (from outer to inner):

file
class        class FOnlineAsyncTaskSteamRetrieveLeaderboard : public FOnlineAsyncTaskSteam
function     FOnlineAsyncTaskSteamRetrieveLeaderboard

Source code excerpt:

		bInit(false),
		LeaderboardName(InLeaderboardName),
		SortMethod(InSortMethod),
		DisplayFormat(InDisplayFormat),
		bFindOnly(false)
	{
	}

	/** Find a leaderboard implementation */

#Loc: <Workspace>/Engine/Plugins/Online/OnlineSubsystemSteam/Source/Private/OnlineLeaderboardInterfaceSteam.cpp:651

Scope (from outer to inner):

file
class        class FOnlineAsyncTaskSteamRetrieveLeaderboard : public FOnlineAsyncTaskSteam
function     FOnlineAsyncTaskSteamRetrieveLeaderboard

Source code excerpt:

		bInit(false),
		LeaderboardName(InLeaderboardName),
		SortMethod(ELeaderboardSort::Ascending),
		DisplayFormat(ELeaderboardFormat::Number),
		bFindOnly(true)
	{
	}

	/**

#Loc: <Workspace>/Engine/Plugins/Online/OnlineSubsystemSteam/Source/Private/OnlineLeaderboardInterfaceSteam.cpp:676

Scope (from outer to inner):

file
class        class FOnlineAsyncTaskSteamRetrieveLeaderboard : public FOnlineAsyncTaskSteam
function     virtual void Tick

Source code excerpt:

		if (!bInit)
		{
			CreateOrFindLeaderboard(LeaderboardName, SortMethod, DisplayFormat);
			bInit = true;
		}

		if (CallbackHandle != k_uAPICallInvalid)
		{
			bool bFailedCall = false;

#Loc: <Workspace>/Engine/Plugins/Online/OnlineSubsystemSteam/Source/Private/OnlineLeaderboardInterfaceSteam.cpp:728

Scope (from outer to inner):

file
class        class FOnlineAsyncTaskSteamRetrieveLeaderboard : public FOnlineAsyncTaskSteam
function     virtual void Finalize

Source code excerpt:

			Leaderboard->TotalLeaderboardRows = SteamUserPtr->GetLeaderboardEntryCount(CallbackResults.m_hSteamLeaderboard);
			Leaderboard->DisplayFormat = FromSteamLeaderboardDisplayType(SteamUserPtr->GetLeaderboardDisplayType(CallbackResults.m_hSteamLeaderboard));
			Leaderboard->SortMethod = FromSteamLeaderboardSortMethod(SteamUserPtr->GetLeaderboardSortMethod(CallbackResults.m_hSteamLeaderboard));
			Leaderboard->AsyncState = EOnlineAsyncTaskState::Done;
		}
		else
		{
			Leaderboard->LeaderboardHandle = -1;
			Leaderboard->TotalLeaderboardRows = 0;

#Loc: <Workspace>/Engine/Plugins/Online/OnlineSubsystemSteam/Source/Private/OnlineLeaderboardInterfaceSteam.cpp:1495

Scope (from outer to inner):

file
function     bool FOnlineLeaderboardsSteam::WriteLeaderboards

Source code excerpt:

	{
		// Will create or retrieve the leaderboards, triggering async calls as appropriate
		CreateLeaderboard(WriteObject.LeaderboardNames[LeaderboardIdx], WriteObject.SortMethod, WriteObject.DisplayFormat);
	}

	// Update stats columns associated with the leaderboards (before actual leaderboard update so we can retrieve the updated stat)
	FStatPropertyArray LeaderboardStats;
	for (int32 LeaderboardIdx = 0; LeaderboardIdx < NumLeaderboards; LeaderboardIdx++)
	{

#Loc: <Workspace>/Engine/Plugins/Online/OnlineSubsystemSteam/Source/Private/OnlineLeaderboardInterfaceSteam.cpp:1561

Scope (from outer to inner):

file
function     void FOnlineLeaderboardsSteam::CreateLeaderboard

Source code excerpt:

}

void FOnlineLeaderboardsSteam::CreateLeaderboard(const FName& LeaderboardName, ELeaderboardSort::Type SortMethod, ELeaderboardFormat::Type DisplayFormat)
{
	FScopeLock ScopeLock(&LeaderboardMetadataLock);
	FLeaderboardMetadataSteam* LeaderboardMetadata = GetLeaderboardMetadata(LeaderboardName);

	// Don't allow multiple attempts to create a leaderboard unless it's actually failed before
	bool bPrevAttemptFailed = (LeaderboardMetadata != NULL && LeaderboardMetadata->LeaderboardHandle == -1 &&

#Loc: <Workspace>/Engine/Plugins/Online/OnlineSubsystemSteam/Source/Private/OnlineLeaderboardInterfaceSteam.cpp:1573

Scope (from outer to inner):

file
function     void FOnlineLeaderboardsSteam::CreateLeaderboard

Source code excerpt:

	if (LeaderboardMetadata == NULL || bPrevAttemptFailed)
	{
		FLeaderboardMetadataSteam* NewLeaderboard = new (Leaderboards) FLeaderboardMetadataSteam(LeaderboardName, SortMethod, DisplayFormat);
		NewLeaderboard->AsyncState = EOnlineAsyncTaskState::InProgress;
		SteamSubsystem->QueueAsyncTask(new FOnlineAsyncTaskSteamRetrieveLeaderboard(SteamSubsystem, LeaderboardName, SortMethod, DisplayFormat));
	}
	// else request already in flight or already found
}

void FOnlineLeaderboardsSteam::FindLeaderboard(const FName& LeaderboardName)
{

#Loc: <Workspace>/Engine/Plugins/Online/OnlineSubsystemSteam/Source/Private/OnlineLeaderboardInterfaceSteam.h:78

Scope (from outer to inner):

file
class        class FOnlineLeaderboardsSteam : public IOnlineLeaderboards

Source code excerpt:

	 * If the leaderboard already exists, the leaderboard data will still be retrieved
	 * @param LeaderboardName name of leaderboard to create
	 * @param SortMethod method the leaderboard scores will be sorted, ignored if leaderboard exists
	 * @param DisplayFormat type of data the leaderboard represents, ignored if leaderboard exists
	 */
	void CreateLeaderboard(const FName& LeaderboardName, ELeaderboardSort::Type SortMethod, ELeaderboardFormat::Type DisplayFormat);

	/**
	 *	Start an async task to find a leaderboard with the Steam backend
	 * If the leaderboard doesn't exist, a warning will be generated
	 * @param LeaderboardName name of leaderboard to create
	 */
	void FindLeaderboard(const FName& LeaderboardName);

	/**

#Loc: <Workspace>/Engine/Plugins/Online/OnlineSubsystemSteam/Source/Private/OnlineSubsystemSteamTypes.h:670

Scope (from outer to inner):

file
class        class FLeaderboardMetadataSteam

Source code excerpt:

    FName LeaderboardName;
	/** Sort Method */
	ELeaderboardSort::Type SortMethod;
	/** Display Type */
	ELeaderboardFormat::Type DisplayFormat;
	/** Number of entries on leaderboard */
	int32 TotalLeaderboardRows;
	/** Handle to leaderboard */
    SteamLeaderboard_t LeaderboardHandle;

#Loc: <Workspace>/Engine/Plugins/Online/OnlineSubsystemSteam/Source/Private/OnlineSubsystemSteamTypes.h:682

Scope (from outer to inner):

file
class        class FLeaderboardMetadataSteam
function     FLeaderboardMetadataSteam

Source code excerpt:

	FLeaderboardMetadataSteam(const FName& InLeaderboardName, ELeaderboardSort::Type InSortMethod, ELeaderboardFormat::Type InDisplayFormat) :
		LeaderboardName(InLeaderboardName),
		SortMethod(InSortMethod),
		DisplayFormat(InDisplayFormat),
		TotalLeaderboardRows(0),
		LeaderboardHandle(-1),
		AsyncState(EOnlineAsyncTaskState::NotStarted)
	{
	}

#Loc: <Workspace>/Engine/Plugins/Online/OnlineSubsystemSteam/Source/Private/OnlineSubsystemSteamTypes.h:692

Scope (from outer to inner):

file
class        class FLeaderboardMetadataSteam
function     FLeaderboardMetadataSteam

Source code excerpt:

	FLeaderboardMetadataSteam(const FName& InLeaderboardName) :
		LeaderboardName(InLeaderboardName),
		SortMethod(ELeaderboardSort::None),
		DisplayFormat(ELeaderboardFormat::Number),
		TotalLeaderboardRows(0),
		LeaderboardHandle(-1),
		AsyncState(EOnlineAsyncTaskState::NotStarted)
	{
	}

#Loc: <Workspace>/Engine/Plugins/Online/OnlineSubsystemUtils/Source/OnlineSubsystemUtils/Private/LeaderboardBlueprintLibrary.cpp:65

Scope (from outer to inner):

file
function     bool ULeaderboardBlueprintLibrary::WriteLeaderboardInteger

Source code excerpt:

	WriteObject.RatedStat = StatName;
	WriteObject.DisplayFormat = ELeaderboardFormat::Number;
	WriteObject.SortMethod = ELeaderboardSort::Descending;
	WriteObject.UpdateMethod = ELeaderboardUpdateMethod::KeepBest;
	WriteObject.SetIntStat(StatName, StatValue);

	return WriteLeaderboardObject(PlayerController, WriteObject);
}

#Loc: <Workspace>/Engine/Plugins/Online/OnlineSubsystemUtils/Source/OnlineSubsystemUtils/Private/Tests/TestLeaderboardInterface.cpp:18

Scope (from outer to inner):

file
class        class TestLeaderboardWrite : public FOnlineLeaderboardWrite
function     TestLeaderboardWrite

Source code excerpt:

		RatedStat = "TestIntStat1";
		DisplayFormat = ELeaderboardFormat::Number;
		SortMethod = ELeaderboardSort::Descending;
		UpdateMethod = ELeaderboardUpdateMethod::KeepBest;
	}
};

/**
 *	Example of a leaderboard read object

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Private/Elements/PCGSortAttributes.cpp:86

Scope (from outer to inner):

file
function     bool FPCGSortAttributesElement::ExecuteInternal

Source code excerpt:

			{
				UPCGPointData* OutputPointData = static_cast<UPCGPointData*>(InputData->DuplicateData());
				PCGAttributeAccessorHelpers::SortByAttribute(*Accessor, *Keys, OutputPointData->GetMutablePoints(), Settings->SortMethod == EPCGSortMethod::Ascending);
				OutputData = OutputPointData;
			}
			else if (const UPCGMetadata* InMetadata = InputData->ConstMetadata())
			{
				// Duplicate data without metadata
				OutputData = InputData->DuplicateData(/*bInitializeMetdata=*/false);

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Private/Elements/PCGSortAttributes.cpp:111

Scope (from outer to inner):

file
function     bool FPCGSortAttributesElement::ExecuteInternal

Source code excerpt:

				}

				PCGAttributeAccessorHelpers::SortByAttribute(*Accessor, *Keys, Entries, Settings->SortMethod == EPCGSortMethod::Ascending);

				OutMetadata->InitializeAsCopy(InputData->ConstMetadata(), &Entries);
			}

			FPCGTaggedData& Output = Outputs.Add_GetRef(Input);
			Output.Data = OutputData;

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Private/Tests/Elements/PCGSortAttributesTest.cpp:36

Scope (from outer to inner):

file
namespace    SortCommonTestData
function     TUniquePtr<FPCGContext> RunSortElementOnData

Source code excerpt:

		check(Settings);
		Settings->InputSource = InputSource;
		Settings->SortMethod = Method;
		FPCGElementPtr TestElement = TestData.Settings->GetElement();

		FPCGTaggedData& SourcePin = TestData.InputData.TaggedData.Emplace_GetRef();
		SourcePin.Pin = PCGPinConstants::DefaultInputLabel;
		SourcePin.Data = InData;

#Loc: <Workspace>/Engine/Plugins/PCG/Source/PCG/Public/Elements/PCGSortAttributes.h:44

Scope (from outer to inner):

file
class        class UPCGSortAttributesSettings : public UPCGSettings

Source code excerpt:


	UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = Settings, meta = (PCG_Overridable))
	EPCGSortMethod SortMethod = EPCGSortMethod::Ascending;
};

class FPCGSortAttributesElement : public IPCGElement
{
protected:
	virtual bool ExecuteInternal(FPCGContext* Context) const override;

#Loc: <Workspace>/Engine/Source/Editor/ContentBrowser/Private/AssetViewSortManager.cpp:378

Scope (from outer to inner):

file
function     void FAssetViewSortManager::SortList

Source code excerpt:

	//double SortListStartTime = FPlatformTime::Seconds();

	TArray<TUniquePtr<FCompareFAssetItemBase>> SortMethod;
	for (int32 PriorityIdx = 0; PriorityIdx < EColumnSortPriority::Max; PriorityIdx++)
	{
		const bool bAscending(SortMode[PriorityIdx] == EColumnSortMode::Ascending);
		const FName& Tag(SortColumnId[PriorityIdx]);

		if (Tag == NAME_None)

#Loc: <Workspace>/Engine/Source/Editor/ContentBrowser/Private/AssetViewSortManager.cpp:391

Scope (from outer to inner):

file
function     void FAssetViewSortManager::SortList

Source code excerpt:

		if (Tag == NameColumnId)
		{
			SortMethod.Add(MakeUnique<FCompareFAssetItemByName>(bAscending, Tag));
		}
		else if (Tag == ClassColumnId)
		{
			SortMethod.Add(MakeUnique<FCompareFAssetItemByClass>(bAscending, Tag));
		}
		else if (Tag == PathColumnId)
		{
			SortMethod.Add(MakeUnique<FCompareFAssetItemByPath>(bAscending, Tag));
		}
		else
		{
			UObject::FAssetRegistryTag::ETagType TagType = UObject::FAssetRegistryTag::TT_Hidden;
			const bool bFoundCustomColumn = FindAndRefreshCustomColumn(AssetItems, Tag, CustomColumns, TagType);

#Loc: <Workspace>/Engine/Source/Editor/ContentBrowser/Private/AssetViewSortManager.cpp:430

Scope (from outer to inner):

file
function     void FAssetViewSortManager::SortList

Source code excerpt:

			{
				// The property is a Number, compare using atof
				SortMethod.Add(MakeUnique<FCompareFAssetItemByTagNumerical>(bAscending, Tag));
			}
			else if (TagType == UObject::FAssetRegistryTag::TT_Dimensional)
			{
				// The property is a series of Numbers representing dimensions, compare by using atof for each Number, delimited by an "x"
				SortMethod.Add(MakeUnique<FCompareFAssetItemByTagDimensional>(bAscending, Tag));
			}
			else if (TagType != UObject::FAssetRegistryTag::ETagType::TT_Hidden)
			{
				// Unknown or alphabetical, sort alphabetically either way
				SortMethod.Add(MakeUnique<FCompareFAssetItemByTag>(bAscending, Tag));
			}
		}
	}

	// Sort the list...
	if (SortMethod.Num() > 0)
	{
		TUniquePtr<FCompareFAssetItemBase> PrimarySortMethod = MoveTemp(SortMethod[EColumnSortPriority::Primary]);
		check(PrimarySortMethod);
		SortMethod.RemoveAt(0);

		// Move all the comparisons to the primary sort method
		PrimarySortMethod->SetNextComparisons(SortMethod);
		AssetItems.Sort(*(PrimarySortMethod.Get()));

		// Move the comparisons back for ease of cleanup
		SortMethod = MoveTemp(PrimarySortMethod->GetNextComparisons());
		SortMethod.Insert(MoveTemp(PrimarySortMethod), 0);
	}

	// Cleanup the methods we no longer need.
	for (int32 PriorityIdx = 0; PriorityIdx < SortMethod.Num(); PriorityIdx++)
	{
		SortMethod[PriorityIdx].Reset();
	}
	SortMethod.Empty();

	//UE_LOG(LogContentBrowser, Warning/*VeryVerbose*/, TEXT("FAssetViewSortManager Sort Time: %0.4f seconds."), FPlatformTime::Seconds() - SortListStartTime);
}

void FAssetViewSortManager::ExportColumnsToCSV(TArray<TSharedPtr<FAssetViewItem>>& AssetItems, TArray<FName>& ColumnList, const TArray<FAssetViewCustomColumn>& CustomColumns, FString& OutString) const
{

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/GeometryCollectionEngine/Private/ChaosBlueprint.cpp:138

Scope (from outer to inner):

file
function     void UChaosDestructionListener::UpdateTransformSettings

Source code excerpt:

	if (IsEventListening())
	{
		bWantsOnUpdateTransform = CollisionEventRequestSettings.SortMethod == EChaosCollisionSortMethod::SortByNearestFirst ||
								  BreakingEventRequestSettings.SortMethod == EChaosBreakingSortMethod::SortByNearestFirst ||
							      TrailingEventRequestSettings.SortMethod == EChaosTrailingSortMethod::SortByNearestFirst ||
								  RemovalEventRequestSettings.SortMethod == EChaosRemovalSortMethod::SortByNearestFirst;
	}
	else
	{
		bWantsOnUpdateTransform = false;
	}

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/GeometryCollectionEngine/Private/ChaosBlueprint.cpp:382

Scope (from outer to inner):

file
function     void UChaosDestructionListener::SortCollisionEvents

Source code excerpt:

}

void UChaosDestructionListener::SortCollisionEvents(TArray<FChaosCollisionEventData>& CollisionEvents, EChaosCollisionSortMethod SortMethod)
{
	if (ChaosCollisionFilter.IsValid())
	{
		ChaosCollisionFilter->SortEvents(CollisionEvents, SortMethod, GetComponentTransform());
	}
}

void UChaosDestructionListener::SortBreakingEvents(TArray<FChaosBreakingEventData>& BreakingEvents, EChaosBreakingSortMethod SortMethod)
{
	if (ChaosBreakingFilter.IsValid())
	{
		ChaosBreakingFilter->SortEvents(BreakingEvents, SortMethod, GetComponentTransform());
	}
}

void UChaosDestructionListener::SortTrailingEvents(TArray<FChaosTrailingEventData>& TrailingEvents, EChaosTrailingSortMethod SortMethod)
{
	if (ChaosTrailingFilter.IsValid())
	{
		ChaosTrailingFilter->SortEvents(TrailingEvents, SortMethod, GetComponentTransform());
	}
}

void UChaosDestructionListener::SortRemovalEvents(TArray<FChaosRemovalEventData>& RemovalEvents, EChaosRemovalSortMethod SortMethod)
{
	if (ChaosRemovalFilter.IsValid())
	{
		ChaosRemovalFilter->SortEvents(RemovalEvents, SortMethod, GetComponentTransform());
	}
}

void UChaosDestructionListener::RegisterChaosEvents(FPhysScene* Scene)
{
	Chaos::FPhysicsSolver* Solver = Scene->GetSolver();

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/GeometryCollectionEngine/Private/ChaosBreakingEventFilter.cpp:49

Scope (from outer to inner):

file
function     void FChaosBreakingEventFilter::FilterEvents

Source code excerpt:

		}

		SortEvents(FilteredDataArray, BreakingEventRequestSettings->SortMethod, ChaosComponentTransform);
	}
}

void FChaosBreakingEventFilter::SortEvents(TArray<FChaosBreakingEventData>& InOutBreakingEvents, EChaosBreakingSortMethod SortMethod, const FTransform& InTransform)
{
	struct FSortBreakingByMassMaxToMin
	{
		FORCEINLINE bool operator()(const FChaosBreakingEventData& Lhs, const FChaosBreakingEventData& Rhs) const
		{
			return Lhs.Mass > Rhs.Mass;

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/GeometryCollectionEngine/Private/ChaosBreakingEventFilter.cpp:90

Scope (from outer to inner):

file
function     void FChaosBreakingEventFilter::SortEvents

Source code excerpt:


	// Apply the sort
	switch (SortMethod)
	{
	case EChaosBreakingSortMethod::SortNone:
		break;

	case EChaosBreakingSortMethod::SortByHighestMass:
		InOutBreakingEvents.Sort(FSortBreakingByMassMaxToMin());

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/GeometryCollectionEngine/Private/ChaosCollisionEventFilter.cpp:71

Scope (from outer to inner):

file
function     void FChaosCollisionEventFilter::FilterEvents

Source code excerpt:

		}

		SortEvents(FilteredDataArray, CollisionEventRequestSettings->SortMethod, ChaosComponentTransform);
	}
}

void FChaosCollisionEventFilter::SortEvents(TArray<FChaosCollisionEventData>& InOutCollisionEvents, EChaosCollisionSortMethod SortMethod, const FTransform& InTransform)
{
	struct FSortCollisionByMassMaxToMin
	{
		FORCEINLINE bool operator()(const FChaosCollisionEventData& Lhs, const FChaosCollisionEventData& Rhs) const
		{
			return FMath::Max(Lhs.Mass1, Lhs.Mass2) > FMath::Max(Rhs.Mass1, Rhs.Mass2);

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/GeometryCollectionEngine/Private/ChaosCollisionEventFilter.cpp:118

Scope (from outer to inner):

file
function     void FChaosCollisionEventFilter::SortEvents

Source code excerpt:

	};

	switch (SortMethod)
	{
	case EChaosCollisionSortMethod::SortNone:
		break;

	case EChaosCollisionSortMethod::SortByHighestMass:
		InOutCollisionEvents.Sort(FSortCollisionByMassMaxToMin());

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/GeometryCollectionEngine/Private/ChaosRemovalEventFilter.cpp:46

Scope (from outer to inner):

file
function     void FChaosRemovalEventFilter::FilterEvents

Source code excerpt:

		}

		SortEvents(FilteredDataArray, RemovalEventRequestSettings->SortMethod, ChaosComponentTransform);
	}
}

void FChaosRemovalEventFilter::SortEvents(TArray<FChaosRemovalEventData>& InOutRemovalEvents, EChaosRemovalSortMethod SortMethod, const FTransform& InTransform)
{
	struct FSortRemovalByMassMaxToMin
	{
		FORCEINLINE bool operator()(const FChaosRemovalEventData& Lhs, const FChaosRemovalEventData& Rhs) const
		{
			return Lhs.Mass > Rhs.Mass;

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/GeometryCollectionEngine/Private/ChaosRemovalEventFilter.cpp:78

Scope (from outer to inner):

file
function     void FChaosRemovalEventFilter::SortEvents

Source code excerpt:


	// Apply the sort
	switch (SortMethod)
	{
	case EChaosRemovalSortMethod::SortNone:
		break;

	case EChaosRemovalSortMethod::SortByHighestMass:
		InOutRemovalEvents.Sort(FSortRemovalByMassMaxToMin());

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/GeometryCollectionEngine/Private/ChaosTrailingEventFilter.cpp:58

Scope (from outer to inner):

file
function     void FChaosTrailingEventFilter::FilterEvents

Source code excerpt:

		}

		SortEvents(FilteredDataArray, TrailingEventRequestSettings->SortMethod, ChaosComponentTransform);
	}
}

void FChaosTrailingEventFilter::SortEvents(TArray<FChaosTrailingEventData>& InOutTrailingEvents, EChaosTrailingSortMethod SortMethod, const FTransform& InTransform)
{
	struct FSortTrailingByMassMaxToMin
	{
		FORCEINLINE bool operator()(const FChaosTrailingEventData& Lhs, const FChaosTrailingEventData& Rhs) const
		{
			return Lhs.Mass > Rhs.Mass;

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/GeometryCollectionEngine/Private/ChaosTrailingEventFilter.cpp:98

Scope (from outer to inner):

file
function     void FChaosTrailingEventFilter::SortEvents

Source code excerpt:


	// Apply the sort
	switch (SortMethod)
	{
	case EChaosTrailingSortMethod::SortNone:
		break;

	case EChaosTrailingSortMethod::SortByHighestMass:
		InOutTrailingEvents.Sort(FSortTrailingByMassMaxToMin());

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/GeometryCollectionEngine/Public/ChaosBlueprint.h:167

Scope (from outer to inner):

file
class        class UChaosDestructionListener : public USceneComponent

Source code excerpt:

	// Sorts collision events according to the given sort method	
	UFUNCTION(BlueprintCallable, Category = "Destruction Listener", meta = (WorldContext = "WorldContextObject"))
	GEOMETRYCOLLECTIONENGINE_API void SortCollisionEvents(UPARAM(ref) TArray<FChaosCollisionEventData>& CollisionEvents, EChaosCollisionSortMethod SortMethod);

	// Sorts breaking events according to the given sort method	
	UFUNCTION(BlueprintCallable, Category = "Destruction Listener", meta = (WorldContext = "WorldContextObject"))
	GEOMETRYCOLLECTIONENGINE_API void SortBreakingEvents(UPARAM(ref) TArray<FChaosBreakingEventData>& BreakingEvents, EChaosBreakingSortMethod SortMethod);

	// Sorts trailing events according to the given sort method	
	UFUNCTION(BlueprintCallable, Category = "Destruction Listener", meta = (WorldContext = "WorldContextObject"))
	GEOMETRYCOLLECTIONENGINE_API void SortTrailingEvents(UPARAM(ref) TArray<FChaosTrailingEventData>& TrailingEvents, EChaosTrailingSortMethod SortMethod);

	// Sorts removal events according to the given sort method	
	UFUNCTION(BlueprintCallable, Category = "Destruction Listener", meta = (WorldContext = "WorldContextObject"))
	GEOMETRYCOLLECTIONENGINE_API void SortRemovalEvents(UPARAM(ref) TArray<FChaosRemovalEventData>& RemovalEvents, EChaosRemovalSortMethod SortMethod);

private:
	// Updates the scene component transform settings
	GEOMETRYCOLLECTIONENGINE_API void UpdateTransformSettings();

	// Retrieves data from solvers

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/GeometryCollectionEngine/Public/ChaosBreakingEventFilter.h:73

Scope: file

Source code excerpt:

	/** The method used to sort the breaking events. */
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Sort")
	EChaosBreakingSortMethod SortMethod;

	FChaosBreakingEventRequestSettings()
		: MaxNumberOfResults(0)
		, MinRadius(0.0f)
		, MinSpeed(0.0f)
		, MinMass(0.0f)
		, MaxDistance(0.0f)
		, SortMethod(EChaosBreakingSortMethod::SortByHighestMass)
	{}
};

class FChaosBreakingEventFilter : public IChaosEventFilter<Chaos::FBreakingDataArray, TArray<FChaosBreakingEventData>, EChaosBreakingSortMethod>
{
public:

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/GeometryCollectionEngine/Public/ChaosBreakingEventFilter.h:92

Scope (from outer to inner):

file
class        class FChaosBreakingEventFilter : public IChaosEventFilter<Chaos::FBreakingDataArray, TArray<FChaosBreakingEventData>, EChaosBreakingSortMethod>

Source code excerpt:

	GEOMETRYCOLLECTIONENGINE_API virtual void FilterEvents(const FTransform& ChaosComponentTransform, const Chaos::FBreakingDataArray& RawBreakingDataArray) override;

	GEOMETRYCOLLECTIONENGINE_API virtual void SortEvents(TArray<FChaosBreakingEventData>& InOutBreakingEvents, EChaosBreakingSortMethod SortMethod, const FTransform& InTransform) override;

private:
	FChaosBreakingEventFilter() : BreakingEventRequestSettings(nullptr) {}
	const FChaosBreakingEventRequestSettings* BreakingEventRequestSettings;
};

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/GeometryCollectionEngine/Public/ChaosCollisionEventFilter.h:94

Scope: file

Source code excerpt:

	/** The method used to sort the collision events. */
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Sort")
	EChaosCollisionSortMethod SortMethod;

	FChaosCollisionEventRequestSettings()
		: MaxNumberResults(0)
		, MinMass(0.0f)
		, MinSpeed(0.0f)
		, MinImpulse(0.0f)
		, MaxDistance(0.0f)
		, SortMethod(EChaosCollisionSortMethod::SortByHighestMass)
	{}
};

class FChaosCollisionEventFilter : public IChaosEventFilter<Chaos::FCollisionDataArray, TArray<FChaosCollisionEventData>, EChaosCollisionSortMethod>
 {
public:

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/GeometryCollectionEngine/Public/ChaosCollisionEventFilter.h:113

Scope (from outer to inner):

file
class        class FChaosCollisionEventFilter : public IChaosEventFilter<Chaos::FCollisionDataArray, TArray<FChaosCollisionEventData>, EChaosCollisionSortMethod>

Source code excerpt:


	GEOMETRYCOLLECTIONENGINE_API virtual void FilterEvents(const FTransform& ChaosComponentTransform, const Chaos::FCollisionDataArray& RawCollisionDataArray) override;
	GEOMETRYCOLLECTIONENGINE_API virtual void SortEvents(TArray<FChaosCollisionEventData>& InOutCollisionEvents, EChaosCollisionSortMethod SortMethod, const FTransform& InTransform) override;

private:
	FChaosCollisionEventFilter() : CollisionEventRequestSettings(nullptr) { check(false);  }
	const FChaosCollisionEventRequestSettings* CollisionEventRequestSettings;
};

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/GeometryCollectionEngine/Public/ChaosFilter.h:26

Scope (from outer to inner):

file
class        class IChaosEventFilter

Source code excerpt:

	* Optionally Sort events based on increasing or decreasing values of FilteredDataArray fields
	*/
	virtual void SortEvents(DestinationType& InOutFilteredEvents, SortMethodType SortMethod, const FTransform& InTransform) = 0;


	/**
	* Gain access to the filtered results
	*/
	const DestinationType& GetFilteredResults() const { return FilteredDataArray; };

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/GeometryCollectionEngine/Public/ChaosRemovalEventFilter.h:63

Scope: file

Source code excerpt:

	/** The method used to sort the removal events. */
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Sort")
	EChaosRemovalSortMethod SortMethod;

	FChaosRemovalEventRequestSettings()
		: MaxNumberOfResults(0)
		, MinMass(0.0f)
		, MaxDistance(0.0f)
		, SortMethod(EChaosRemovalSortMethod::SortByHighestMass)
	{
	}
};

class FChaosRemovalEventFilter
	: public IChaosEventFilter<Chaos::FRemovalDataArray, TArray<FChaosRemovalEventData>, EChaosRemovalSortMethod>

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/GeometryCollectionEngine/Public/ChaosRemovalEventFilter.h:82

Scope (from outer to inner):

file
class        class FChaosRemovalEventFilter : public IChaosEventFilter<Chaos::FRemovalDataArray, TArray<FChaosRemovalEventData>, EChaosRemovalSortMethod>

Source code excerpt:

	GEOMETRYCOLLECTIONENGINE_API virtual void FilterEvents(const FTransform& ChaosComponentTransform, const Chaos::FRemovalDataArray& RawRemovalDataArray) override;

	GEOMETRYCOLLECTIONENGINE_API virtual void SortEvents(TArray<FChaosRemovalEventData>& InOutRemovalEvents, EChaosRemovalSortMethod SortMethod, const FTransform& InTransform) override;

private:
	FChaosRemovalEventFilter() : RemovalEventRequestSettings(nullptr) {}
	const FChaosRemovalEventRequestSettings* RemovalEventRequestSettings;
};

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/GeometryCollectionEngine/Public/ChaosTrailingEventFilter.h:82

Scope: file

Source code excerpt:

	/** The method used to sort the breaking events. */
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Sort")
	EChaosTrailingSortMethod SortMethod;

	FChaosTrailingEventRequestSettings()
		: MaxNumberOfResults(0)
		, MinMass(0.0f)
		, MinSpeed(0.0f)
		, MinAngularSpeed(0.0f)
		, MaxDistance(0.0f)
		, SortMethod(EChaosTrailingSortMethod::SortByHighestMass)
	{
	}
};

class FChaosTrailingEventFilter 
	: public IChaosEventFilter<Chaos::FTrailingDataArray, TArray<FChaosTrailingEventData>, EChaosTrailingSortMethod>

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/GeometryCollectionEngine/Public/ChaosTrailingEventFilter.h:103

Scope (from outer to inner):

file
class        class FChaosTrailingEventFilter : public IChaosEventFilter<Chaos::FTrailingDataArray, TArray<FChaosTrailingEventData>, EChaosTrailingSortMethod>

Source code excerpt:

	GEOMETRYCOLLECTIONENGINE_API virtual void FilterEvents(const FTransform& ChaosComponentTransform, const Chaos::FTrailingDataArray& RawTrailingDataArray) override;

	GEOMETRYCOLLECTIONENGINE_API virtual void SortEvents(TArray<FChaosTrailingEventData>& InOutTrailingEvents, EChaosTrailingSortMethod SortMethod, const FTransform& InTransform) override;

private:
	FChaosTrailingEventFilter() : TrailingEventRequestSettings(nullptr) {}
	const FChaosTrailingEventRequestSettings* TrailingEventRequestSettings;
};