file
function     void FDeviceProfileServicesUIManager::SetProfile

void FDeviceProfileServicesUIManager::SetProfile( const FString& DeviceProfileName )
{
	// Save the profile name to an ini file
	if ( DeviceProfileName != TEXT( "Default" ) )
	{
		const FString INISection = "SelectedProfile"; // Section in the game ini to store our selections
		const FString INIKeyBase = "ProfileItem"; // Key to the stored device profiles
		const int32 MaxItems = 4; // Max history

		// Array to store the existing items

file
function     void FDeviceProfileServicesUIManager::SetProfile

		// Remove the current item if it exists - we will re-add it at the top of the array later
		const int32 ItemIndex = CurItems.Find( DeviceProfileName );
		if ( ItemIndex != INDEX_NONE )
		{
			CurItems.RemoveAt( ItemIndex );
		}
		else if ( CurItems.Num() == MaxItems )
		{

file
function     void FDeviceProfileServicesUIManager::SetProfile

		// Add the new profile to the top of the array
		CurItems.Insert( DeviceProfileName, 0 );

		// Clear the ini section
		GConfig->EmptySection( *INISection, GEditorPerProjectIni );

		// Re-write the .ini file
		for ( int32 ItemIdx = 0; ItemIdx < CurItems.Num(); ++ItemIdx )

file
class        class FDeviceProfileServicesUIManager : public IDeviceProfileServicesUIManager

	virtual void GetProfilesByType( TArray<UDeviceProfile*>& OutDeviceProfiles, const FString& InType ) override;
	virtual const FName GetPlatformIconName( const FString& DeviceName ) const override;
	virtual void SetProfile( const FString& DeviceProfileName ) override;

protected:

	/** Generates the UI icon list. */
	void CreatePlatformMap();

file
class        class IDeviceProfileServicesUIManager

	 * Set a profile - add the type to an INI file so it can be used in a history view.
	 *
	 * @param DeviceProfileName The platform type.
	 */
	virtual void SetProfile( const FString& DeviceProfileName ) = 0;
};

file
function     void FLevelEditorModule::BindGlobalLevelEditorCommands
lambda-function

				const ERHIFeatureLevel::Type FeatureLevel = GetMaxSupportedFeatureLevel(ShaderPlatform);
				return FPreviewPlatformInfo(FeatureLevel, ShaderPlatform, Item.PlatformName, Item.ShaderFormat, Item.DeviceProfileName, true, Item.PreviewShaderPlatformName);
			};

			FPreviewPlatformInfo PreviewFeatureLevelInfo = GetPreviewFeatureLevelInfo();

			ActionList.MapAction(
				Commands.PreviewPlatformOverrides[Index],

			FUICommandInfoDecl(
				this->AsShared(),
				FName(*FString::Printf(TEXT("PreviewPlatformOverrides_%s_%s_%s"), *Item.PlatformName.ToString(), *Item.ShaderFormat.ToString(), *Item.DeviceProfileName.ToString())),
				FriendlyNameBuilder.ToText(),
				Item.MenuTooltip)
			.UserInterfaceType(EUserInterfaceActionType::Check)
			.DefaultChord(FInputChord())
		);
	}

file
function     const FSlateBrush* SLevelViewportToolBar::GetDevicePreviewMenuLabelIcon

{
	TSharedRef<SLevelViewport> ViewportRef = Viewport.Pin().ToSharedRef();
	FString DeviceProfileName = ViewportRef->GetDeviceProfileString();

	FName PlatformIcon = NAME_None;
	if( !DeviceProfileName.IsEmpty() && DeviceProfileName != "Default" )
	{
		static FName DeviceProfileServices( "DeviceProfileServices" );

		IDeviceProfileServicesModule& ScreenDeviceProfileUIServices = FModuleManager::LoadModuleChecked<IDeviceProfileServicesModule>(TEXT( "DeviceProfileServices"));
		IDeviceProfileServicesUIManagerPtr UIManager = ScreenDeviceProfileUIServices.GetProfileServicesManager();

		PlatformIcon = UIManager->GetDeviceIconName( DeviceProfileName );

		return FAppStyle::GetOptionalBrush( PlatformIcon );
	}

	return nullptr;
}

file
function     void SLevelViewportToolBar::SetLevelProfile

}

void SLevelViewportToolBar::SetLevelProfile( FString DeviceProfileName )
{
	TSharedRef<SLevelViewport> ViewportRef = Viewport.Pin().ToSharedRef();
	ViewportRef->SetDeviceProfileString( DeviceProfileName );

	IDeviceProfileServicesModule& ScreenDeviceProfileUIServices = FModuleManager::LoadModuleChecked<IDeviceProfileServicesModule>(TEXT( "DeviceProfileServices"));
	IDeviceProfileServicesUIManagerPtr UIManager = ScreenDeviceProfileUIServices.GetProfileServicesManager();
	UIManager->SetProfile( DeviceProfileName );
}

void SLevelViewportToolBar::GeneratePlacedCameraMenuEntries(FToolMenuSection& Section, TArray<ACameraActor*> Cameras) const
{
	FSlateIcon CameraIcon( FAppStyle::GetAppStyleSetName(), "ClassIcon.CameraComponent" );

file
class        class SLevelViewportToolBar : public SViewportToolBar

	 * Set the level profile, and save the selection to an .ini file.
	 *
	 * @param DeviceProfileName - The selected device profile
	 */
	void SetLevelProfile( FString DeviceProfileName );

	/**
	 * Generates the toolbar view mode options menu content 
	 *
	 * @return The widget containing the options menu content
	 */
	TSharedRef<SWidget> GenerateOptionsMenu();

file
function     FPreviewPlatformInfo

	,	PreviewPlatformName(InPreviewPlatformName)
	,	PreviewShaderFormatName(InPreviewShaderFormatName)
	,	DeviceProfileName(InDeviceProfileName)
	,	bPreviewFeatureLevelActive(InbPreviewFeatureLevelActive)
	,	PreviewShaderPlatformName(InShaderPlatformName)
	{}

	/** The feature level we should use when loading or creating a new world */
	ERHIFeatureLevel::Type PreviewFeatureLevel;

	/** The device profile to preview. */
	FName DeviceProfileName;

	/** Is feature level preview currently active */
	bool bPreviewFeatureLevelActive;
	
	/** Preview Shader Platform Name */
	FName PreviewShaderPlatformName;

file
function     bool Matches

	bool Matches(const FPreviewPlatformInfo& Other) const
	{
		return PreviewFeatureLevel == Other.PreviewFeatureLevel && ShaderPlatform == Other.ShaderPlatform && PreviewPlatformName == Other.PreviewPlatformName && PreviewShaderFormatName == Other.PreviewShaderFormatName && DeviceProfileName == Other.DeviceProfileName && PreviewShaderPlatformName == Other.PreviewShaderPlatformName;
	}

	/** Return platform name like "Android", or NAME_None if none is set or the preview feature level is not active */
	FName GetEffectivePreviewPlatformName() const
	{
		return bPreviewFeatureLevelActive ? PreviewPlatformName : NAME_None;

file
function     static void SaveFeatureLevelAsDisabled

	Settings->bPreviewFeatureLevelActive = PreviewPlatform.bPreviewFeatureLevelActive;
	Settings->bPreviewFeatureLevelWasDefault = (PreviewPlatform.PreviewFeatureLevel == GMaxRHIFeatureLevel);
	Settings->PreviewDeviceProfileName = PreviewPlatform.DeviceProfileName;
	Settings->PreviewShaderPlatformName = PreviewPlatform.PreviewShaderPlatformName;
}

void UEditorEngine::SetPreviewPlatform(const FPreviewPlatformInfo& NewPreviewPlatform, bool bSaveSettings)
{
	// Get the requested preview platform, make sure it is valid.

file
function     void UEditorEngine::SetPreviewPlatform

	{
		//Override the current device profile.
		if (PreviewPlatform.DeviceProfileName != NAME_None)
		{
			if (UDeviceProfile* DP = UDeviceProfileManager::Get().FindProfile(PreviewPlatform.DeviceProfileName.ToString(), false))
			{
				UDeviceProfileManager::Get().SetPreviewDeviceProfile(DP);
			}
		}
	}

file
function     void UEditorEngine::ToggleFeatureLevelPreview

		GShaderPlatformForFeatureLevel[PreviewPlatform.PreviewFeatureLevel] = PreviewPlatform.ShaderPlatform;

		if (PreviewPlatform.DeviceProfileName != NAME_None)
		{
			if (UDeviceProfile* DP = UDeviceProfileManager::Get().FindProfile(PreviewPlatform.DeviceProfileName.ToString(), false))
			{
				UDeviceProfileManager::Get().SetPreviewDeviceProfile(DP);
			}
		}
		else
		{

file
function     void UEditorEngine::SaveEditorFeatureLevel

	Settings->bPreviewFeatureLevelActive = PreviewPlatform.bPreviewFeatureLevelActive;
	Settings->bPreviewFeatureLevelWasDefault = (PreviewPlatform.PreviewFeatureLevel == GMaxRHIFeatureLevel);
	Settings->PreviewDeviceProfileName = PreviewPlatform.DeviceProfileName;
	Settings->PreviewShaderPlatformName = PreviewPlatform.PreviewShaderPlatformName;
	Settings->PostEditChange();
}

bool UEditorEngine::GetPreviewPlatformName(FName& PlatformName) const
{

file
function     bool IConsoleManager::VisitPlatformCVarsForEmulation

}

bool IConsoleManager::VisitPlatformCVarsForEmulation(FName PlatformName, const FString& DeviceProfileName, TFunctionRef<void(const FString& CVarName, const FString& CVarValue, EConsoleVariableFlags SetBy)> Visit)
{
	// we can't get to Scalability code in here (it's in Engine) but we still want to apply the default level... 
	// there is a static_assert in UDeviceProfile::ExpandDeviceProfileCVars to make sure the default doesn't change from this value
	const int DefaultScalabilityLevel = 3;

	// get the config system for the platform the DP uses

file
function     bool IConsoleManager::VisitPlatformCVarsForEmulation

		{
			// skip this if we didn't specify one
			if (DeviceProfileName.Len() == 0)
			{
				continue;
			}
			if (!FCoreDelegates::GatherDeviceProfileCVars.IsBound())
			{
				UE_LOG(LogConsoleManager, Warning, TEXT("Attempted to get CVars for another platform before FCoreDelegates::GatherDeviceProfileCVars was bound to a callback. CVar values are likely incorrect."));

file
function     bool IConsoleManager::VisitPlatformCVarsForEmulation

			bDeleteSection = true;

			UE_LOG(LogConsoleManager, Verbose, TEXT("Gathering device profile cvars for %s, platform config %s"), *DeviceProfileName, *PlatformName.ToString());
			// run the delegate (this code can't get into DP code directly, so we use a delegate), and walk over the results
			for (TPair<FName, FString>& Pair : FCoreDelegates::GatherDeviceProfileCVars.Execute(DeviceProfileName))
			{
				NewSection->Add(Pair);
				UE_LOG(LogConsoleManager, Verbose, TEXT("   %s = %s"), *Pair.Key.ToString(), *Pair.Value);
			}
            
            Section = NewSection;

file
class        class FConsoleVariableExtendedData : public FConsoleVariableBase

#if ALLOW_OTHER_PLATFORM_CONFIG

	virtual TSharedPtr<IConsoleVariable> GetPlatformValueVariable(FName PlatformName, const FString& DeviceProfileName) override;
	virtual bool HasPlatformValueVariable(FName PlatformName, const FString& DeviceProfileName) override;
	virtual void ClearPlatformVariables(FName PlatformName) override;

	// cache of the values of this cvar on other platforms
	TMap<FName, TSharedPtr<IConsoleVariable> > PlatformValues;
	FRWLock PlatformValuesLock;
	friend FConsoleManager;

 * Platform name as the DP name. This matches up with how GetPlatformValueVariable() was generally used in the past - get the CVar using the platform-named
 * DeviceProfile. 
 * If DeviceProfileName is the GSpecialDPNameForPremadePlatformKey, then that indicates PlatformName is already a PlatformKey that
 * was created with this function before, so just return the PlatformName untouched. This makes is so we don't need two versions of functions
 * that take a PlatformName and DeviceProfileName, and we don't need to keep re-creating PlatformKeys
 */
static FName MakePlatformKey(FName PlatformName, const FString& DeviceProfileName)
{
	// a bit of a hack to say PlatformName is already a Key
	if (DeviceProfileName == GSpecialDPNameForPremadePlatformKey || PlatformName == NAME_None)
	{
		return PlatformName;
	}
	return *(PlatformName.ToString() + TEXT("/") + (DeviceProfileName.Len() ? DeviceProfileName : PlatformName.ToString()));
}

template<class T>
bool FConsoleVariableExtendedData<T>::HasPlatformValueVariable(FName PlatformName, const FString& DeviceProfileName)
{
	// cheap lock here, contention is very rare
	FRWScopeLock Lock(PlatformValuesLock, SLT_Write);
	return PlatformValues.Contains(MakePlatformKey(PlatformName, DeviceProfileName));
}

template<class T>
TSharedPtr<IConsoleVariable> FConsoleVariableExtendedData<T>::GetPlatformValueVariable(FName PlatformName, const FString& DeviceProfileName)
{
	// if we have GSpecialDPNameForPremadePlatformKey passed in, we have already gone through the
	// Load and we have a premade key in PlatformName
	if (DeviceProfileName != GSpecialDPNameForPremadePlatformKey)
	{
		// make sure we have cached this platform/DP
		IConsoleManager::Get().LoadAllPlatformCVars(PlatformName, DeviceProfileName);
	}

	// we have assumed in the past that we would return at least the constructor version, so create one if we are explicitly asking
	// this can happen when .ini files don't give a value to a cvar, but we are asking for a platform's value anyway - in
	// which case we want the constructor value, not the current platform's value
	if (!HasPlatformValueVariable(PlatformName, DeviceProfileName))
	{
		FindOrCreatePlatformCVar(this, MakePlatformKey(PlatformName, DeviceProfileName));
	}
	
	// cheap lock here, contention is very rare
	FRWScopeLock Lock(PlatformValuesLock, SLT_Write);
	return PlatformValues.FindRef(MakePlatformKey(PlatformName, DeviceProfileName));
}

template<class T>
void FConsoleVariableExtendedData<T>::ClearPlatformVariables(FName PlatformName)
{
	FRWScopeLock Lock(PlatformValuesLock, SLT_Write);

file
function     static void SetUnsetCVar

	
	FString PlatformName;
	FString DeviceProfileName;
	int32 PlatformDelim = CVarName.Find(TEXT("@"));
	if (PlatformDelim > 0)
	{
		PlatformName = CVarName.Mid(0, PlatformDelim);
		if (PlatformName.Contains(TEXT("/")))
		{
			FString Plat;
			PlatformName.Split(TEXT("/"), &Plat, &DeviceProfileName);
			PlatformName = *Plat;
		}

		CVarName = CVarName.Mid(PlatformDelim + 1);
	}

file
function     static void SetUnsetCVar

	if (PlatformName.Len())
	{
		CVar = CVar->GetPlatformValueVariable(*PlatformName, *DeviceProfileName).Get();
		if (CVar == nullptr)
		{
			Ar.Logf(TEXT("Failed to get CVar for platform %s"), *PlatformName);
			return;
		}
	}

file
function     bool FConsoleManager::ProcessUserConsoleInput

	// look for the <cvar>@<platform[/deviceprofile]> syntax
	FName PlatformName;
	FString DeviceProfileName;
	if (Param1.Contains(TEXT("@")))
	{
		FString Left, Right;
		Param1.Split(TEXT("@"), &Left, &Right);

		if (Left.Len() && Right.Len())

file
function     bool FConsoleManager::ProcessUserConsoleInput

			{
				FString Plat;
				Right.Split(TEXT("/"), &Plat, &DeviceProfileName);
				PlatformName = *Plat;
			}
			else
			{
				PlatformName = *Right;
			}

file
function     bool FConsoleManager::ProcessUserConsoleInput

		{
#if ALLOW_OTHER_PLATFORM_CONFIG
			PlatformCVar = CVar->GetPlatformValueVariable(PlatformName, DeviceProfileName);
			CVar = PlatformCVar.Get();
			if (!CVar)
			{
				Ar.Logf(TEXT("Unable find CVar %s for platform %s (possibly invalid platform name?)"), *Param1, *PlatformName.ToString());
				return false;
			}

file
function     void FConsoleManager::LoadAllPlatformCVars

#if ALLOW_OTHER_PLATFORM_CONFIG

void FConsoleManager::LoadAllPlatformCVars(FName PlatformName, const FString& DeviceProfileName)
{
	FName PlatformKey = MakePlatformKey(PlatformName, DeviceProfileName);
	
	// protect the cached CVar info from two threads trying to get a platform CVar at once, and both attempting to load all of the cvars at the same time
	FScopeLock Lock(&CachedPlatformsAndDeviceProfilesLock);
	if (CachedPlatformsAndDeviceProfiles.Contains(PlatformKey))
	{
		return;

file
function     void FConsoleManager::LoadAllPlatformCVars

	
	// use the platform's base DeviceProfile for emulation
	VisitPlatformCVarsForEmulation(PlatformName, DeviceProfileName.IsEmpty() ? PlatformName.ToString() : DeviceProfileName,
		[PlatformName, PlatformKey](const FString& CVarName, const FString& CVarValue, EConsoleVariableFlags SetByAndPreview)
	{
		// make sure the named cvar exists
		IConsoleVariable* CVar = IConsoleManager::Get().FindConsoleVariable(*CVarName);
		if (CVar == nullptr)
		{

file
function     void FConsoleManager::PreviewPlatformCVars

}

void FConsoleManager::PreviewPlatformCVars(FName PlatformName, const FString& DeviceProfileName, FName PreviewModeTag)
{
	UE_LOG(LogConsoleManager, Display, TEXT("Previewing Platform '%s', DeviceProfile '%s', ModeTag '%s'"), *PlatformName.ToString(), *DeviceProfileName, *PreviewModeTag.ToString());
	
	LoadAllPlatformCVars(PlatformName, DeviceProfileName.Len() ? DeviceProfileName : PlatformName.ToString());
	
	FName PlatformKey = MakePlatformKey(PlatformName, DeviceProfileName);

	for (auto Pair : ConsoleObjects)
	{
		if (IConsoleVariable* CVar = Pair.Value->AsVariable())
		{
			// we want Preview but not Cheat

file
function     void FConsoleManager::ClearAllPlatformCVars

}

void FConsoleManager::ClearAllPlatformCVars(FName PlatformName, const FString& DeviceProfileName)
{
	FName PlatformKey = MakePlatformKey(PlatformName, DeviceProfileName);

	// protect the cached CVar info from two threads trying to get a platform CVar at once, and both attempting to load all of the cvars at the same time
	FScopeLock Lock(&CachedPlatformsAndDeviceProfilesLock);
	
	if (!CachedPlatformsAndDeviceProfiles.Contains(PlatformKey))
	{

file
function     static void ParsePreviewPlatforms

				for (int DPIndex = 0; DPIndex < DeviceProfileNames.Num(); DPIndex++)
				{
					Item.DeviceProfileName = *DeviceProfileNames[DPIndex].TrimStartAndEnd();
					if (DPIndex < FriendlyNames.Num())
					{
						Item.OptionalFriendlyNameOverride = FText::FromString(FriendlyNames[DPIndex].TrimStartAndEnd());
					}
					else if (DeviceProfileNames.Num() > 1)
					{
						Item.OptionalFriendlyNameOverride = FText::FromString(Item.DeviceProfileName.ToString());
					}
									
					PreviewPlatformMenuItems.Add(Item);
				}
			}
		}

file
class        class FConsoleManager :public IConsoleManager

	CORE_API virtual void UnsetAllConsoleVariablesWithTag(FName Tag, EConsoleVariableFlags Priority) override;
#if ALLOW_OTHER_PLATFORM_CONFIG
	CORE_API virtual void LoadAllPlatformCVars(FName PlatformName, const FString& DeviceProfileName=FString()) override;
	CORE_API virtual void ClearAllPlatformCVars(FName PlatformName=NAME_None, const FString& DeviceProfileName=FString()) override;
	CORE_API virtual void PreviewPlatformCVars(FName PlatformName, const FString& DeviceProfileName, FName PreviewModeTag) override;
#endif
	
private: // ----------------------------------------------------

	/** Map of console variables and commands, indexed by the name of that command or variable */
	// [name] = pointer (pointer must not be 0)

file
class        class IConsoleVariable : public IConsoleObject

	 * Note: If this causes a compile error due to pure virtual, make sure your IConsoleVariable subclass inherits from FConsoleVariableExtendedData
	 */
	virtual TSharedPtr<IConsoleVariable> GetPlatformValueVariable(FName PlatformName, const FString& DeviceProfileName=FString()) = 0;

	/**
	 * Checks if the CVar has a cached value for the given platform
	 */
	virtual bool HasPlatformValueVariable(FName PlatformName, const FString& DeviceProfileName=FString()) = 0;

	/**
	 * Used only for debugging/iterating, this will clear all of the other platform's cvar objects, which will 
	 * force a fresh lookup (with fresh ini files, likely) on next call to GetPlatformValueVariable
	 */
	virtual void ClearPlatformVariables(FName PlatformName=NAME_None)

	 *
	 * @param PlatformName The platform name (the ini name, so Windows, not Win64)
	 * @param DeviceProfileName If this is non-empty, the given deviceprofile will be loaded from the platform's inis and inserted into the CVars
	 * @param Visit the callback to run for each CVar found
	 */
	static CORE_API bool VisitPlatformCVarsForEmulation(FName PlatformName, const FString& DeviceProfileName, TFunctionRef<void(const FString& CVarName, const FString& CVarValue, EConsoleVariableFlags SetBy)> Visit);
	
	/**
	 * Loads all platform cvars, which can be retrieved with IConsoleVariable::GetPlatformValueVariable. If DeviceProfileName is empty, it will use the
	 *  DevicePlatform named the same as the Platform
	 */
	virtual void LoadAllPlatformCVars(FName PlatformName, const FString& DeviceProfileName=FString()) = 0;
	
	/**
	 * Applies the cvars from the platform/DeviceProfile pair (can be blank to use the platform's named DP) and sets into the SetByPreview  priority, with the PreviewModeTag
	 * to be unset later
	 */
	virtual void PreviewPlatformCVars(FName PlatformName, const FString& DeviceProfileName, FName PreviewModeTag) = 0;

	/**
	 * Empties the cache for the given Platform/DP for all CVars. If using NAME_None for Platofrm, this will wipe every cached platform/DP value. If DeviceProfileName
	 * is empty, it will use the PlatfomName as the DeviceProfile name
	 */
	virtual void ClearAllPlatformCVars(FName PlatformName=NAME_None, const FString& DeviceProfileName=FString()) = 0;

#endif

	/**
	  * When a plugin is unmounted, it needs to unset cvars that it had set when it was mounted. This will unset and fixup all
	  * variables with the given Tag

file
class        class FCoreDelegates

	// Called when the CVar (ConsoleManager) needs to retrieve CVars for a deviceprofile for another platform - this dramatically simplifies module dependencies
	typedef TMap<FName, FString> FCVarKeyValueMap;
	static CORE_API TDelegate<FCVarKeyValueMap(const FString& DeviceProfileName)> GatherDeviceProfileCVars;
#endif

	// Called when an error occurred.
	static CORE_API FSimpleMulticastDelegate OnShutdownAfterError;

	// Called when appInit is called, very early in startup

file
class        class FCoreDelegates

	using FOnFileOpenedForReadFromPakFile UE_DEPRECATED(5.2, "Use template instantiation instead as `TMulticastDelegate<void(const TCHAR* PakFile, const TCHAR* FileName)>`") = TMulticastDelegate<void(const TCHAR* PakFile, const TCHAR* FileName)>;
#if ALLOW_OTHER_PLATFORM_CONFIG
	using FGatherDeviceProfileCVars UE_DEPRECATED(5.2, "Use template instantiation instead as `TDelegate<FCVarKeyValueMap(const FString& DeviceProfileName)>`") = TDelegate<FCVarKeyValueMap(const FString& DeviceProfileName)>;
#endif
	using FGatherAdditionalLocResPathsDelegate UE_DEPRECATED(5.2, "Use template instantiation instead as `TMulticastDelegate<void(TArray<FString>&)>`") = TMulticastDelegate<void(TArray<FString>&)>;
	using FWorldOriginOffset UE_DEPRECATED(5.2, "Use template instantiation instead as `TMulticastDelegate<void(class UWorld*, FIntVector, FIntVector)>`") = TMulticastDelegate<void(class UWorld*, FIntVector, FIntVector)>;
	using FStarvedGameLoop UE_DEPRECATED(5.2, "Use template instantiation instead as `TDelegate<void()>`") = TDelegate<void()>;
	using FOnTemperatureChange UE_DEPRECATED(5.2, "Use template instantiation instead as `TMulticastDelegate<void(ETemperatureSeverity)>`") = TMulticastDelegate<void(ETemperatureSeverity)>;
	using FOnLowPowerMode UE_DEPRECATED(5.2, "Use template instantiation instead as `TMulticastDelegate<void(bool)>`") = TMulticastDelegate<void(bool)>;

	FText MenuTooltip;
	FText IconText;
	FName DeviceProfileName;
};

#endif


// Information about a platform loaded from disk

file
class        class UDeviceProfileManager : public UObject

	 * Walk the device profile/fragment chain to get the final set ot CVars in a unified way
	 */
	static ENGINE_API TMap<FName, FString> GatherDeviceProfileCVars(const FString& DeviceProfileName, EDeviceProfileMode GatherMode);

	/**
	 * Gather all the cvars from the static device profile and then add all of the possible cvars+values from the dynamic/matched rule fragments.
	 */
	static ENGINE_API TMap<FName, TSet<FString>> GetAllReferencedDeviceProfileCVars(UDeviceProfile* DeviceProfile);

	 * Set the active device profile - set via the device profile blueprint.
	 *
	 * @param DeviceProfileName - The profile name.
	 */
	ENGINE_API void SetActiveDeviceProfile( UDeviceProfile* DeviceProfile );

	/**
	* Override CVar value change callback
	*/
	ENGINE_API void HandleDeviceProfileOverrideChange();

	/** Sees if two profiles are considered identical for saving */
	ENGINE_API bool AreProfilesTheSame(UDeviceProfile* Profile1, UDeviceProfile* Profile2) const;

file
class        class UDeviceProfileManager : public UObject

	 * the Mode will control how the settings are handled
	 */
	static ENGINE_API void SetDeviceProfileCVars(const FString& DeviceProfileName);


	/** Read and process all of the fragment matching rules. Returns an array containing the names of fragments selected. */
	static ENGINE_API TArray<FSelectedFragmentProperties> FindMatchingFragments(const FString& ParentDP, class FConfigCacheIni* PreviewConfigSystem);

	/** Read and discover all of the possible fragments referenced by the matching rules. Returns an array containing the names of fragments selected. */

file
function     void FDumpFPSChartToEndpoint::HandleBasicStats

	PrintToEndpoint(FString::Printf(TEXT("\tOS: %s %s"), *OSMajor, *OSMinor));
	PrintToEndpoint(FString::Printf(TEXT("\tCPU: %s %s"), *CPUVendor, *CPUBrand));
	PrintToEndpoint(FString::Printf(TEXT("\tDeviceProfile: %s"), *DeviceProfileName));

	FString CompositeGPUString = FString::Printf(TEXT("\tGPU: %s"), *ActualGPUBrand);
	if (ActualGPUBrand != DesktopGPUBrand)
	{
		CompositeGPUString += FString::Printf(TEXT(" (desktop adapter %s)"), *DesktopGPUBrand);
	}

file
function     void FDumpFPSChartToEndpoint::DumpChart

	int32 NumFrames = (int32)Chart.GetNumFrames();
	MapName = MoveTemp(InMapName);
	DeviceProfileName = MoveTemp(InDeviceProfileName);

	if (TotalTime > WallClockTimeFromStartOfCharting)
	{
		UE_LOG(LogChartCreation, Log, TEXT("Weirdness: wall clock time (%f) is smaller than total frame time (%f)"), WallClockTimeFromStartOfCharting, TotalTime);
	}

file
function     virtual void HandleBasicStats

		ParamArray.Add(FAnalyticsEventAttribute(TEXT("OS"), FString::Printf(TEXT("%s %s"), *OSMajor, *OSMinor)));
		ParamArray.Add(FAnalyticsEventAttribute(TEXT("CPU"), FString::Printf(TEXT("%s %s"), *CPUVendor, *CPUBrand)));
		ParamArray.Add(FAnalyticsEventAttribute(TEXT("DeviceProfile"), DeviceProfileName));

		if (bIncludeClientHWInfo)
		{
			ParamArray.Add(FAnalyticsEventAttribute(TEXT("DesktopGPU"), DesktopGPUBrand)); //@TODO: Cut this one out entirely?
			ParamArray.Add(FAnalyticsEventAttribute(TEXT("GPUAdapter"), ActualGPUBrand));

file
function     virtual void HandleBasicStats

		FPSChartRow = FPSChartRow.Replace(TEXT("TOKEN_BUILDCONFIG"), LexToString(FApp::GetBuildConfiguration()), ESearchCase::CaseSensitive);
		FPSChartRow = FPSChartRow.Replace(TEXT("TOKEN_DATESTAMP"), *FString::Printf(TEXT("%s"), *FDateTime::Now().ToString()), ESearchCase::CaseSensitive);
		FPSChartRow = FPSChartRow.Replace(TEXT("TOKEN_DEVICE_PROFILE"), *DeviceProfileName, ESearchCase::CaseSensitive);

		FPSChartRow = FPSChartRow.Replace(TEXT("TOKEN_OS"), *FString::Printf(TEXT("%s %s"), *OSMajor, *OSMinor), ESearchCase::CaseSensitive);
		FPSChartRow = FPSChartRow.Replace(TEXT("TOKEN_CPU"), *FString::Printf(TEXT("%s %s"), *CPUVendor, *CPUBrand), ESearchCase::CaseSensitive);
		FPSChartRow = FPSChartRow.Replace(TEXT("TOKEN_GPU"), *FString::Printf(TEXT("%s"), *ActualGPUBrand), ESearchCase::CaseSensitive);
		FPSChartRow = FPSChartRow.Replace(TEXT("TOKEN_SETTINGS_RES"), *FString::Printf(TEXT("%.2f"), ScalabilityQuality.ResolutionQuality), ESearchCase::CaseSensitive);
		FPSChartRow = FPSChartRow.Replace(TEXT("TOKEN_SETTINGS_VD"), *FString::Printf(TEXT("%d"), ScalabilityQuality.ViewDistanceQuality), ESearchCase::CaseSensitive);

file
function     void FPerformanceTrackingChart::Reset

	StartBatteryLevel = -1;
	StopBatteryLevel = -1;
	DeviceProfileName = UDeviceProfileManager::Get().GetActiveDeviceProfileName();
	bIsChartingPaused = false;
}


void FPerformanceTrackingChart::AccumulateWith(const FPerformanceTrackingChart& Chart)
{

file
function     void FPerformanceTrackingChart::StartCharting

	StartTemperatureLevel = FPlatformMisc::GetDeviceTemperatureLevel();
	StartBatteryLevel = FPlatformMisc::GetBatteryLevel();
	DeviceProfileName = UDeviceProfileManager::Get().GetActiveDeviceProfileName();
	bIsChartingPaused = false;
}

void FPerformanceTrackingChart::StopCharting()
{
	StopTemperatureLevel = FPlatformMisc::GetDeviceTemperatureLevel();

file
function     void FPerformanceTrackingChart::DumpChartsToOutputLog

	{
		FDumpFPSChartToLogEndpoint Endpoint(*Chart);
		Endpoint.DumpChart(WallClockElapsed, InMapName, DeviceProfileName);
	}
}

#if ALLOW_DEBUG_FILES
void FPerformanceTrackingChart::DumpChartsToLogFile(double WallClockElapsed, const TArray<const FPerformanceTrackingChart*>& Charts, const FString& InMapName, const FString& LogFileName)
{

file
function     void FPerformanceTrackingChart::DumpChartsToLogFile

		{
			FDumpFPSChartToFileEndpoint FileEndpoint(*pChart, OutputFile);
			FileEndpoint.DumpChart(WallClockElapsed, InMapName, DeviceProfileName);
		}

		OutputFile->Logf(LINE_TERMINATOR LINE_TERMINATOR LINE_TERMINATOR);

		// Flush, close and delete.
		delete OutputFile;

file
function     void FPerformanceTrackingChart::DumpChartToAnalyticsParams

		// Dump all the basic stats
		FDumpFPSChartToAnalyticsArray AnalyticsEndpoint(*this, InParamArray, bIncludeClientHWInfo, bIncludeHistograms);
		AnalyticsEndpoint.DumpChart(AccumulatedChartTime, InMapName, DeviceProfileName);

		if (bIncludeClientHWInfo)
		{
			// Dump some extra non-chart-based stats

			// Get the system memory stats

file
function     void FPerformanceTrackingChart::DumpChartsToHTML

		FString NewRow = FPSChartRowStructure;
		FDumpFPSChartToHTMLEndpoint HTMLEndpoint(*Chart, /*inout*/ NewRow);
		HTMLEndpoint.DumpChart(WallClockElapsed, InMapName, DeviceProfileName);

		NewRows += NewRow;
	}

	// See whether file already exists and load it into string if it does.
	FString FPSChart;

file
function     UDeviceProfileManager& UDeviceProfileManager::Get
lambda-function

#if ALLOW_OTHER_PLATFORM_CONFIG
		FCoreDelegates::GatherDeviceProfileCVars.BindLambda([](const FString& DeviceProfileName) { return UDeviceProfileManager::Get().GatherDeviceProfileCVars(DeviceProfileName, EDeviceProfileMode::DPM_CacheValues); });
#endif

		// let any other code that needs the DPManager to run now
		FDelayedAutoRegisterHelper::RunAndClearDelayedAutoRegisterDelegates(EDelayedRegisterRunPhase::DeviceProfileManagerReady);
	}
	return *DeviceProfileManagerSingleton;

file
function     TMap<FName, FString> UDeviceProfileManager::GatherDeviceProfileCVars

}

TMap<FName, FString> UDeviceProfileManager::GatherDeviceProfileCVars(const FString& DeviceProfileName, EDeviceProfileMode GatherMode)
{
	FConfigCacheIni* ConfigSystem = GConfig;
	// build up cvars into a map
	TMap<FName, FString> DeviceProfileCVars;
	TArray<FSelectedFragmentProperties> FragmentsSelected;
	TSet<FString> FragmentCVarKeys;

file
function     TMap<FName, FString> UDeviceProfileManager::GatherDeviceProfileCVars

#if ALLOW_OTHER_PLATFORM_CONFIG
		// caching is not done super early, so we can assume DPs have been found now
		UDeviceProfile* Profile = UDeviceProfileManager::Get().FindProfile(DeviceProfileName, true);
		if (Profile == nullptr)
		{
			UE_LOG(LogDeviceProfileManager, Log, TEXT("Unable to find DeviceProfile '%s' for gathering cvars for caching. Aborting...."), *DeviceProfileName);
			check(Profile);
			return DeviceProfileCVars;
		}

		// use the DP's platform's configs, NOT the running platform
		ConfigSystem = FConfigCacheIni::ForPlatform(*Profile->DeviceType);

file
function     TMap<FName, FString> UDeviceProfileManager::GatherDeviceProfileCVars

		if(GatherMode == EDeviceProfileMode::DPM_CacheValues)
		{
			FragmentsSelected = FindMatchingFragments(DeviceProfileName, ConfigSystem);
		}
#else
		checkNoEntry();
#endif
	}
	else

file
function     TMap<FName, FString> UDeviceProfileManager::GatherDeviceProfileCVars

		if (PlatformFragmentsSelected.Num() == 0)
		{
			PlatformFragmentsSelected = FindMatchingFragments(DeviceProfileName, GConfig);
			if(PlatformFragmentsSelected.Num())
			{
				// Store the fragment string:
				FString MatchedFragmentString = FragmentPropertyArrayToFragmentString(PlatformFragmentsSelected, false, false, true);
				FGenericCrashContext::SetEngineData(TEXT("DeviceProfile.MatchedFragmentsSorted"), MatchedFragmentString);
			}

file
function     TMap<FName, FString> UDeviceProfileManager::GatherDeviceProfileCVars

	// For each device profile, starting with the selected and working our way up the BaseProfileName tree,
	FString BaseDeviceProfileName = DeviceProfileName;
	bool bReachedEndOfTree = BaseDeviceProfileName.IsEmpty();
	while (bReachedEndOfTree == false)
	{
		FString CurrentSectionName = BaseDeviceProfileName + SectionSuffix;

		// check if there is a section named for the DeviceProfile

file
function     void UDeviceProfileManager::SetDeviceProfileCVars

}

void UDeviceProfileManager::SetDeviceProfileCVars(const FString& DeviceProfileName)
{
	// walk over the parent chain, gathering the cvars this DP inherits and contains
	TMap<FName, FString> DeviceProfileCVars = GatherDeviceProfileCVars(DeviceProfileName, EDeviceProfileMode::DPM_SetCVars);

	// reset some global state
	DeviceProfileScalabilityCVars.Empty();

	// we should have always popped away old values by the time we get here
	check(PushedSettings.Num() == 0);

file
class        class FPerformanceTrackingChart : public IPerformanceDataConsumer

	/** WARNING: This value could technically change while data collection is ongoing. Hanlding such changes is not handled by this code. */
	FString DeviceProfileName;

	bool bIsChartingPaused;
	
	// memory stats
	uint32 NumFramesAtCriticalMemoryPressure;
	uint64 MaxPhysicalMemory;

	double WallClockTimeFromStartOfCharting; // This can be much larger than TotalTime if the chart was paused or long frames were omitted
	FString MapName;
	FString DeviceProfileName;

	float AvgGPUFrameTime;
	float AvgRenderThreadFrameTime;
	float AvgGameThreadFrameTime;

	double TotalFlushAsyncLoadingTimeInMS;

file
function     bool ULyraHotfixManager::HotfixIniFile

		for (const auto& DPSection : AsConst(DeviceProfileHotfixConfig))
		{
			FString DeviceProfileName, DeviceProfileClass;
			if (DPSection.Key.Split(TEXT(" "), &DeviceProfileName, &DeviceProfileClass) && DeviceProfileClass == *UDeviceProfile::StaticClass()->GetName())
			{
				Keys.Add(DeviceProfileName);
			}
		}

		// Check if any of the hotfixed device profiles are referenced by the currently active profile(s):
		bHasPendingDeviceProfileHotfix = UDeviceProfileManager::Get().DoActiveProfilesReference(Keys);
		UE_LOG(LogHotfixManager, Log, TEXT("Active device profile was referenced by hotfix = %d"), (uint32)bHasPendingDeviceProfileHotfix);