ManifestName

ManifestName

#Overview

name: ManifestName

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

It is referenced in 49 C++ source files. Also referenced in 1 C# build file meaning it may affect the build system logic.

#Summary

#Usage in the C++ source code

The purpose of ManifestName is to specify the name of the localization manifest file used in Unreal Engine’s localization system. Here are the key points about this variable:

  1. It is used in the localization and internationalization subsystems of Unreal Engine, primarily for managing text translations and localization resources.

  2. The ManifestName is typically set in configuration files and used by various localization-related commandlets and tools.

  3. It’s often used in conjunction with other localization-related variables like ArchiveName and SourcePath to define the structure of localization data.

  4. The value is usually set to something like “Game.manifest” or “{ProjectName}.manifest”.

  5. The manifest file specified by ManifestName contains metadata about localizable text in the project, including source text, context, and namespace information.

  6. It’s used in functions that load, save, or process localization data, such as FLocTextHelper::LoadAll() or FJsonInternationalizationManifestSerializer::SerializeManifestToFile().

  7. Developers should be aware that changing the ManifestName could affect the localization pipeline and tools that depend on consistent naming conventions.

  8. Best practices include using a consistent naming convention across projects and ensuring the ManifestName is properly set in all relevant configuration files.

  9. When working with localization systems, always ensure the ManifestName is correctly specified to avoid issues with loading or saving localization data.

  10. In some cases, the ManifestName may be derived from other project settings, such as the project name, to maintain consistency.

#Setting Variables

#References In INI files

<Workspace>/Engine/Config/Localization/Category.ini:5, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Editor.ini:5, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/EditorTutorials.ini:10, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Engine.ini:4, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/Keywords.ini:4, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/PortableObjectExport.ini:15, section: [GatherTextStep0]
<Workspace>/Engine/Config/Localization/PortableObjectExport.ini:23, section: [GatherTextStep1]
<Workspace>/Engine/Config/Localization/PortableObjectExport.ini:31, section: [GatherTextStep2]
<Workspace>/Engine/Config/Localization/PortableObjectExport.ini:39, section: [GatherTextStep3]
<Workspace>/Engine/Config/Localization/PortableObjectExport.ini:47, section: [GatherTextStep4]
<Workspace>/Engine/Config/Localization/PortableObjectImport.ini:15, section: [GatherTextStep0]
<Workspace>/Engine/Config/Localization/PortableObjectImport.ini:23, section: [GatherTextStep1]
<Workspace>/Engine/Config/Localization/PortableObjectImport.ini:31, section: [GatherTextStep2]
<Workspace>/Engine/Config/Localization/PortableObjectImport.ini:39, section: [GatherTextStep3]
<Workspace>/Engine/Config/Localization/PortableObjectImport.ini:47, section: [GatherTextStep4]
<Workspace>/Engine/Config/Localization/PropertyNames.ini:5, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/RepairData.ini:13, section: [GatherTextStep0]
<Workspace>/Engine/Config/Localization/RepairData.ini:21, section: [GatherTextStep1]
<Workspace>/Engine/Config/Localization/RepairData.ini:28, section: [GatherTextStep2]
<Workspace>/Engine/Config/Localization/RepairData.ini:36, section: [GatherTextStep3]
<Workspace>/Engine/Config/Localization/RepairData.ini:43, section: [GatherTextStep4]
<Workspace>/Engine/Config/Localization/RepairData.ini:51, section: [GatherTextStep5]
<Workspace>/Engine/Config/Localization/RepairData.ini:58, section: [GatherTextStep6]
<Workspace>/Engine/Config/Localization/RepairData.ini:66, section: [GatherTextStep7]
<Workspace>/Engine/Config/Localization/RepairData.ini:73, section: [GatherTextStep8]
<Workspace>/Engine/Config/Localization/RepairData.ini:81, section: [GatherTextStep9]
<Workspace>/Engine/Config/Localization/ToolTips.ini:5, section: [CommonSettings]
<Workspace>/Engine/Config/Localization/WordCount.ini:22, section: [GatherTextStep0]
<Workspace>/Engine/Config/Localization/WordCount.ini:29, section: [GatherTextStep1]
<Workspace>/Engine/Config/Localization/WordCount.ini:36, section: [GatherTextStep2]
<Workspace>/Engine/Config/Localization/WordCount.ini:43, section: [GatherTextStep3]


... omitting 30 locations ...

#References in C++ code

#Callsites

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

#Loc: <Workspace>/Engine/Plugins/Runtime/HTTPChunkInstaller/Source/Private/HTTPChunkInstaller.cpp:1349

Scope (from outer to inner):

file
function     void FHTTPChunkInstall::OSSInstallComplete

Source code excerpt:

		// Completed OK. Write the manifest. If the chunk doesn't exist, copy to the content dir.
		// Otherwise, writing the manifest will prompt a copy on next start of the game
		FString ManifestName;
		FString ChunkFdrName;
		uint32 ChunkID;
		bool bIsPatch;
		if (!BuildChunkFolderName(BuildManifest, ChunkFdrName, ManifestName, ChunkID, bIsPatch))
		{
			//Something bad has happened, bail
			EndInstall();
			return;
		}
		UE_LOG(LogHTTPChunkInstaller, Log, TEXT("Chunk %d install complete, preparing to copy to content directory"), ChunkID);
		FString ManifestPath = FPaths::Combine(*InstallDir, *ChunkFdrName, *ManifestName);
		FString HoldingManifestPath = FPaths::Combine(*HoldingDir, *ChunkFdrName, *ManifestName);
		FString SrcDir = FPaths::Combine(*InstallDir, *ChunkFdrName);
		FString DestDir = FPaths::Combine(*ContentDir, *ChunkFdrName);
		bool bCopyDir = InstallDir != ContentDir;
		TArray<IBuildManifestPtr> FoundManifests;
		InstalledManifests.MultiFind(ChunkID, FoundManifests);
		for (const auto& It : FoundManifests)

#Loc: <Workspace>/Engine/Plugins/Runtime/HTTPChunkInstaller/Source/Private/HTTPChunkInstaller.cpp:1439

Scope (from outer to inner):

file
function     void FHTTPChunkInstall::ParseTitleFileManifest

Source code excerpt:

					// Prevent the paks from being mounted by removing the manifest file
					FString ChunkFdrName;
					FString ManifestName;
					bool bIsPatch;
					if (BuildChunkFolderName(InstalledManifest.ToSharedRef(), ChunkFdrName, ManifestName, ChunkID, bIsPatch))
					{
						FString ManifestPath = FPaths::Combine(*ContentDir, *ChunkFdrName, *ManifestName);
						FString HoldingPath = FPaths::Combine(*HoldingDir, *ChunkFdrName, *ManifestName);
						IPlatformFile& PlatformFile = FPlatformFileManager::Get().GetPlatformFile();
						PlatformFile.CreateDirectoryTree(*FPaths::Combine(*HoldingDir, *ChunkFdrName));
						PlatformFile.MoveFile(*HoldingPath, *ManifestPath);
					}
					UE_LOG(LogHTTPChunkInstaller, Log, TEXT("Adding Chunk %d to previous installed manifests"), ChunkID);
					PrevInstallManifests.Add(ChunkID, InstalledManifest);

#Loc: <Workspace>/Engine/Plugins/Runtime/HTTPChunkInstaller/Source/Private/HTTPChunkInstaller.cpp:1468

Scope (from outer to inner):

file
function     bool FHTTPChunkInstall::BuildChunkFolderName

Source code excerpt:

}

bool FHTTPChunkInstall::BuildChunkFolderName(IBuildManifestRef Manifest, FString& ChunkFdrName, FString& ManifestName, uint32& ChunkID, bool& bIsPatch)
{
	auto ChunkIDField = Manifest->GetCustomField(TEXT("ChunkID"));
	auto ChunkPatchField = Manifest->GetCustomField(TEXT("bIsPatch"));

	if (!ChunkIDField.IsValid())
	{

#Loc: <Workspace>/Engine/Plugins/Runtime/HTTPChunkInstaller/Source/Private/HTTPChunkInstaller.cpp:1479

Scope (from outer to inner):

file
function     bool FHTTPChunkInstall::BuildChunkFolderName

Source code excerpt:

	ChunkID = ChunkIDField->AsInteger();
	bIsPatch = ChunkPatchField.IsValid() ? ChunkPatchField->AsString() == TEXT("true") : false;
	ManifestName = FString::Printf(TEXT("chunk_%u"), ChunkID);
	if (bIsPatch)
	{
		ManifestName += TEXT("_patch");
	}
	ManifestName += TEXT(".manifest");
	ChunkFdrName = FString::Printf(TEXT("%s%d"), !bIsPatch ? TEXT("base") : TEXT("patch"), ChunkID);
	return true;
}

bool FHTTPChunkInstall::PrioritizeChunk(uint32 ChunkID, EChunkPriority::Type Priority)
{

#Loc: <Workspace>/Engine/Plugins/Runtime/HTTPChunkInstaller/Source/Public/HTTPChunkInstaller.h:73

Scope (from outer to inner):

file
class        class FHTTPChunkInstall : public FGenericPlatformChunkInstall, public FTSTickerObjectBase

Source code excerpt:

	void BeginChunkInstall(uint32 NextChunkID,IBuildManifestPtr ChunkManifest, IBuildManifestPtr PrevInstallChunkManifest);
	void ParseTitleFileManifest(const FString& ManifestFileHash);
	bool BuildChunkFolderName(IBuildManifestRef Manifest, FString& ChunkFdrName, FString& ManifestName, uint32& ChunkID, bool& bIsPatch);
	void OSSEnumerateFilesComplete(bool bSuccess);
	void OSSReadFileComplete(bool bSuccess, const FString& Filename);
	void OSSInstallComplete(const IBuildInstallerRef& Installer);

	virtual EChunkLocation::Type GetChunkLocation(uint32 ChunkID) override;

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/LocTextHelper.cpp:474

Scope (from outer to inner):

file
function     FLocTextHelper::FLocTextHelper

Source code excerpt:

	: PlatformSplitMode(InPlatformSplitMode)
	, TargetPath(MoveTemp(InTargetPath))
	, ManifestName(MoveTemp(InManifestName))
	, ArchiveName(MoveTemp(InArchiveName))
	, NativeCulture(MoveTemp(InNativeCulture))
	, ForeignCultures(MoveTemp(InForeignCultures))
	, LocFileNotifies(MoveTemp(InLocFileNotifies))
{
	checkf(!TargetPath.IsEmpty(), TEXT("Target path may not be empty!"));
	checkf(!ManifestName.IsEmpty(), TEXT("Manifest name may not be empty!"));
	checkf(!ArchiveName.IsEmpty(), TEXT("Archive name may not be empty!"));

	// todo: We currently infer the target name from the manifest, however once all target files are named consistently the target name should be passed in rather than the manifest/archive names
	TargetName = FPaths::GetBaseFilename(ManifestName);

	// Make sure the native culture isn't in the list of foreign cultures
	if (!NativeCulture.IsEmpty())
	{
		ForeignCultures.Remove(NativeCulture);
	}

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/LocTextHelper.cpp:566

Scope (from outer to inner):

file
function     bool FLocTextHelper::LoadManifest

Source code excerpt:

bool FLocTextHelper::LoadManifest(const ELocTextHelperLoadFlags InLoadFlags, FText* OutError)
{
	const FString ManifestFilePath = TargetPath / ManifestName;
	return LoadManifest(ManifestFilePath, InLoadFlags, OutError);
}

bool FLocTextHelper::LoadManifest(const FString& InManifestFilePath, const ELocTextHelperLoadFlags InLoadFlags, FText* OutError)
{
	Manifest.Reset();

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/LocTextHelper.cpp:579

Scope (from outer to inner):

file
function     bool FLocTextHelper::SaveManifest

Source code excerpt:

bool FLocTextHelper::SaveManifest(FText* OutError) const
{
	const FString ManifestFilePath = TargetPath / ManifestName;
	return SaveManifest(ManifestFilePath, OutError);
}

bool FLocTextHelper::SaveManifest(const FString& InManifestFilePath, FText* OutError) const
{
	if (!Manifest.IsValid())

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/LocalizationConfigurationScript.cpp:309

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateGatherTextConfigFile

Source code excerpt:

			ConfigSection.Add( TEXT("DestinationPath"), DestinationPath );

			ConfigSection.Add( TEXT("ManifestName"), GetManifestFileName(Target) );
			ConfigSection.Add( TEXT("ArchiveName"), GetArchiveFileName(Target) );

			if (Target->Settings.SupportedCulturesStatistics.IsValidIndex(Target->Settings.NativeCultureIndex))
			{
				ConfigSection.Add( TEXT("NativeCulture"), Target->Settings.SupportedCulturesStatistics[Target->Settings.NativeCultureIndex].CultureName );
			}

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/LocalizationConfigurationScript.cpp:570

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateImportTextConfigFile

Source code excerpt:

			}

			ConfigSection.Add( TEXT("ManifestName"), GetManifestFileName(Target) );
			ConfigSection.Add( TEXT("ArchiveName"), GetArchiveFileName(Target) );

			FString POFileName;
			// The import path for a specific culture is a file path.
			if (CultureName.IsSet() && ImportPathOverride.IsSet())
			{

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/LocalizationConfigurationScript.cpp:699

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateExportTextConfigFile

Source code excerpt:

			}

			ConfigSection.Add( TEXT("ManifestName"), GetManifestFileName(Target) );
			ConfigSection.Add( TEXT("ArchiveName"), GetArchiveFileName(Target) );

			FString POFileName;
			// The export path for a specific culture is a file path.
			if (CultureName.IsSet() && ExportPathOverride.IsSet())
			{

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/LocalizationConfigurationScript.cpp:830

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateImportDialogueScriptConfigFile

Source code excerpt:

			}

			ConfigSection.Add(TEXT("ManifestName"), GetManifestFileName(Target));
			ConfigSection.Add(TEXT("ArchiveName"), GetArchiveFileName(Target));

			FString DialogueScriptFileName;
			// The import path for a specific culture is a file path.
			if (CultureName.IsSet() && ImportPathOverride.IsSet())
			{

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/LocalizationConfigurationScript.cpp:946

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateExportDialogueScriptConfigFile

Source code excerpt:

			}

			ConfigSection.Add(TEXT("ManifestName"), GetManifestFileName(Target));
			ConfigSection.Add(TEXT("ArchiveName"), GetArchiveFileName(Target));

			FString DialogueScriptFileName;
			// The export path for a specific culture is a file path.
			if (CultureName.IsSet() && ExportPathOverride.IsSet())
			{

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/LocalizationConfigurationScript.cpp:1009

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateImportDialogueConfigFile

Source code excerpt:

			ConfigSection.Add(TEXT("SourcePath"), SourcePath);

			ConfigSection.Add(TEXT("ManifestName"), GetManifestFileName(Target));
			ConfigSection.Add(TEXT("ArchiveName"), GetArchiveFileName(Target));

			if (Target->Settings.SupportedCulturesStatistics.IsValidIndex(Target->Settings.NativeCultureIndex))
			{
				ConfigSection.Add(TEXT("NativeCulture"), Target->Settings.SupportedCulturesStatistics[Target->Settings.NativeCultureIndex].CultureName);
			}

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/LocalizationConfigurationScript.cpp:1088

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateWordCountReportConfigFile

Source code excerpt:

			ConfigSection.Add( TEXT("DestinationPath"), DestinationPath );

			ConfigSection.Add( TEXT("ManifestName"), GetManifestFileName(Target) );
			ConfigSection.Add( TEXT("ArchiveName"), GetArchiveFileName(Target) );

			for (const FCultureStatistics& CultureStatistics : Target->Settings.SupportedCulturesStatistics)
			{
				ConfigSection.Add( TEXT("CulturesToGenerate"), CultureStatistics.CultureName );
			}

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/LocalizationConfigurationScript.cpp:1139

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateCompileTextConfigFile

Source code excerpt:

			ConfigSection.Add( TEXT("DestinationPath"), DestinationPath );

			ConfigSection.Add( TEXT("ManifestName"), GetManifestFileName(Target) );
			ConfigSection.Add( TEXT("ArchiveName"), GetArchiveFileName(Target) );
			ConfigSection.Add( TEXT("ResourceName"), GetLocResFileName(Target) );

			ConfigSection.Add( TEXT("bSkipSourceCheck"), Target->Settings.CompileSettings.SkipSourceCheck ? TEXT("true") : TEXT("false") );
			ConfigSection.Add( TEXT("bValidateFormatPatterns"), Target->Settings.CompileSettings.ValidateFormatPatterns ? TEXT("true") : TEXT("false") );
			ConfigSection.Add( TEXT("bValidateSafeWhitespace"), Target->Settings.CompileSettings.ValidateSafeWhitespace ? TEXT("true") : TEXT("false") );

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/LocalizationConfigurationScript.cpp:1226

Scope (from outer to inner):

file
namespace    LocalizationConfigurationScript
function     FLocalizationConfigurationScript GenerateRegenerateResourcesConfigFile

Source code excerpt:

			ConfigSection.Add(TEXT("DestinationPath"), DestinationPath);

			ConfigSection.Add(TEXT("ManifestName"), GetManifestFileName(Target));
			ConfigSection.Add(TEXT("ArchiveName"), GetArchiveFileName(Target));
			ConfigSection.Add(TEXT("ResourceName"), GetLocResFileName(Target));

			Script.Add(TEXT("RegenerateResources"), MoveTemp(ConfigSection));
		}

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/TextLocalizationResourceGenerator.cpp:156

Scope (from outer to inner):

file
function     bool FTextLocalizationResourceGenerator::GenerateLocResAndUpdateLiveEntriesFromConfig

Source code excerpt:


	// Get manifest name.
	FString ManifestName;
	if (!GConfig->GetString(*SectionName, TEXT("ManifestName"), ManifestName, InConfigFilePath))
	{
		UE_LOG(LogTextLocalizationResourceGenerator, Error, TEXT("No manifest name specified."));
		return false;
	}

	// Get archive name.

#Loc: <Workspace>/Engine/Source/Developer/Localization/Private/UserGeneratedContentLocalization.cpp:255

Scope (from outer to inner):

file
namespace    UserGeneratedContentLocalization
function     bool ExportLocalization

Source code excerpt:

				ConfigSection.Add(TEXT("DestinationPath"), FPaths::ConvertRelativePathToFull(PluginLocalizationScratchDirectory));

				ConfigSection.Add(TEXT("ManifestName"), FString::Printf(TEXT("%s.manifest"), *Plugin->GetName()));
				ConfigSection.Add(TEXT("ArchiveName"), FString::Printf(TEXT("%s.archive"), *Plugin->GetName()));
				ConfigSection.Add(TEXT("PortableObjectName"), FString::Printf(TEXT("%s.po"), *Plugin->GetName()));

				ConfigSection.Add(TEXT("GatheredSourceBasePath"), FPaths::ConvertRelativePathToFull(Plugin->GetBaseDir()));

				ConfigSection.Add(TEXT("CopyrightNotice"), ExportOptions.CopyrightNotice);

#Loc: <Workspace>/Engine/Source/Developer/Localization/Public/LocTextHelper.h:961

Scope (from outer to inner):

file
class        class FLocTextHelper

Source code excerpt:


	/** Name given to the manifest file for this target (eg, Game.manifest) */
	FString ManifestName;

	/** Name given to the archive files for this target (eg, Game.archive) */
	FString ArchiveName;

	/** Culture code of the native culture (eg, en), or an empty string if the native culture is unknown */
	FString NativeCulture;

#Loc: <Workspace>/Engine/Source/Editor/TranslationEditor/Private/InternationalizationExportSettings.h:37

Scope (from outer to inner):

file
class        class UInternationalizationExportSettings : public UObject

Source code excerpt:

	/** Name of the manifest file */
	UPROPERTY(Category = GatherTextStep, EditAnywhere, config)
	FString ManifestName;

	/** Name of the archive file */
	UPROPERTY(Category = GatherTextStep, EditAnywhere, config)
	FString ArchiveName;

	/** Whether or not to export localization data */

#Loc: <Workspace>/Engine/Source/Editor/TranslationEditor/Private/TranslationDataManager.h:118

Scope (from outer to inner):

file
class        class FTranslationDataManager : public TSharedFromThis<FTranslationDataManager>

Source code excerpt:


	/** Name of the manifest file */
	FString ManifestName;
	/** Path to the project */
	FString ProjectPath;
	/** Name of the archive file */
	FString ArchiveName;
	/** Path to the culture (language, sort of) we are targeting */
	FString CulturePath;

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/ExportDialogueScriptCommandlet.cpp:130

Scope (from outer to inner):

file
function     int32 UExportDialogueScriptCommandlet::Main

Source code excerpt:


	// Get the manifest name
	FString ManifestName;
	if (!GetStringFromConfig(*SectionName, TEXT("ManifestName"), ManifestName, ConfigPath))
	{
		UE_LOG(LogExportDialogueScriptCommandlet, Error, TEXT("No manifest name specified."));
		return -1;
	}

	// Get the archive name

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/ExportDialogueScriptCommandlet.cpp:161

Scope (from outer to inner):

file
function     int32 UExportDialogueScriptCommandlet::Main

Source code excerpt:


	// Load the manifest and all archives
	FLocTextHelper LocTextHelper(SourcePath, ManifestName, ArchiveName, NativeCulture, CulturesToGenerate, GatherManifestHelper->GetLocFileNotifies(), GatherManifestHelper->GetPlatformSplitMode());
	LocTextHelper.SetCopyrightNotice(GatherManifestHelper->GetCopyrightNotice());
	{
		FText LoadError;
		if (!LocTextHelper.LoadAll(ELocTextHelperLoadFlags::LoadOrCreate, &LoadError))
		{
			UE_LOG(LogExportDialogueScriptCommandlet, Error, TEXT("%s"), *LoadError.ToString());

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/GatherTextCommandlet.cpp:191

Scope (from outer to inner):

file
function     int32 UGatherTextCommandlet::ProcessGatherConfig

Source code excerpt:

	FString LocalizationTargetName;
	{
		FString ManifestName;
		GetStringFromConfig(TEXT("CommonSettings"), TEXT("ManifestName"), ManifestName, GatherTextConfigPath);
		LocalizationTargetName = FPaths::GetBaseFilename(ManifestName);
	}

	FString CopyrightNotice;
	if (!GetStringFromConfig(TEXT("CommonSettings"), TEXT("CopyrightNotice"), CopyrightNotice, GatherTextConfigPath))
	{
		CopyrightNotice = GetDefault<UGeneralProjectSettings>()->CopyrightNotice;

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/GenerateGatherArchiveCommandlet.cpp:175

Scope (from outer to inner):

file
function     int32 UGenerateGatherArchiveCommandlet::Main

Source code excerpt:


	// Get manifest name.
	FString ManifestName;
	if( !GetStringFromConfig( *SectionName, TEXT("ManifestName"), ManifestName, GatherTextConfigPath ) )
	{
		UE_LOG( LogGenerateArchiveCommandlet, Error, TEXT("No manifest name specified.") );
		return -1;
	}

	// Get archive name.

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/GenerateGatherArchiveCommandlet.cpp:217

Scope (from outer to inner):

file
function     int32 UGenerateGatherArchiveCommandlet::Main

Source code excerpt:


	// Load the manifest and all archives
	FLocTextHelper LocTextHelper(DestinationPath, ManifestName, ArchiveName, NativeCulture, CulturesToGenerate, GatherManifestHelper->GetLocFileNotifies(), GatherManifestHelper->GetPlatformSplitMode());
	LocTextHelper.SetCopyrightNotice(GatherManifestHelper->GetCopyrightNotice());
	{
		FText LoadError;
		if (!LocTextHelper.LoadAll(ELocTextHelperLoadFlags::LoadOrCreate, &LoadError))
		{
			UE_LOG(LogGenerateArchiveCommandlet, Error, TEXT("%s"), *LoadError.ToString());

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/GenerateGatherManifestCommandlet.cpp:121

Scope (from outer to inner):

file
function     int32 UGenerateGatherManifestCommandlet::Main

Source code excerpt:


	// Get manifest name.
	FString ManifestName;
	if( !GetStringFromConfig( *SectionName, TEXT("ManifestName"), ManifestName, GatherTextConfigPath ) )
	{
		UE_LOG( LogGenerateManifestCommandlet, Error, TEXT("No manifest name specified.") );
		return -1;
	}

	if (!GenerateManifestHelper::IsManifestFileExtensionValid(ManifestName))
	{
		UE_LOG(LogGenerateManifestCommandlet, Error, TEXT("Found manifest file %s is malformed. All manifest files should have a %s extension."), *ManifestName, *GenerateManifestHelper::GetManifestFileExtension());
		return -1;
	}

	if (bRunningInPreview)
	{
		// we change the manifest filename to reflect the preview filename 
		ManifestName = GeneratePreviewManifestHelper::GetPreviewManifestFilename(ManifestName);
	}

	//Grab any manifest dependencies
	TArray<FString> ManifestDependenciesList;
	GetPathArrayFromConfig(*SectionName, TEXT("ManifestDependencies"), ManifestDependenciesList, GatherTextConfigPath);

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/GenerateGatherManifestCommandlet.cpp:188

Scope (from outer to inner):

file
function     int32 UGenerateGatherManifestCommandlet::Main

Source code excerpt:

	GatherManifestHelper->TrimManifest();
	
	const FString ManifestPath = FPaths::ConvertRelativePathToFull(DestinationPath) / ManifestName;
	FText ManifestSaveError;
	if (!GatherManifestHelper->SaveManifest(ManifestPath, &ManifestSaveError))
	{
		UE_LOG(LogGenerateManifestCommandlet, Error, TEXT("%s"), *ManifestSaveError.ToString());
		return -1;
	}

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/GenerateTextLocalizationReportCommandlet.cpp:121

Scope (from outer to inner):

file
function     bool UGenerateTextLocalizationReportCommandlet::ProcessWordCountReport

Source code excerpt:


	// Get manifest name.
	FString ManifestName;
	if( !( GetStringFromConfig( *SectionName, TEXT("ManifestName"), ManifestName, GatherTextConfigPath ) ) )
	{
		UE_LOG(LogGenerateTextLocalizationReportCommandlet, Error, TEXT("No manifest name specified."));
		return false;
	}

	// Get archive name.

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/GenerateTextLocalizationReportCommandlet.cpp:157

Scope (from outer to inner):

file
function     bool UGenerateTextLocalizationReportCommandlet::ProcessWordCountReport

Source code excerpt:


	// Load the manifest and all archives
	FLocTextHelper LocTextHelper(SourcePath, ManifestName, ArchiveName, FString(), CulturesToGenerate, GatherManifestHelper->GetLocFileNotifies(), GatherManifestHelper->GetPlatformSplitMode());
	LocTextHelper.SetCopyrightNotice(GatherManifestHelper->GetCopyrightNotice());
	{
		FText LoadError;
		if (!LocTextHelper.LoadAll(ELocTextHelperLoadFlags::LoadOrCreate, &LoadError))
		{
			UE_LOG(LogGenerateTextLocalizationReportCommandlet, Error, TEXT("%s"), *LoadError.ToString());

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/GenerateTextLocalizationResourceCommandlet.cpp:73

Scope (from outer to inner):

file
function     int32 UGenerateTextLocalizationResourceCommandlet::Main

Source code excerpt:


	// Get manifest name.
	FString ManifestName;
	if( !( GetStringFromConfig( *SectionName, TEXT("ManifestName"), ManifestName, GatherTextConfigPath ) ) )
	{
		UE_LOG(LogGenerateTextLocalizationResourceCommandlet, Error, TEXT("No manifest name specified."));
		return -1;
	}

	// Get archive name.

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/GenerateTextLocalizationResourceCommandlet.cpp:154

Scope (from outer to inner):

file
function     int32 UGenerateTextLocalizationResourceCommandlet::Main

Source code excerpt:


	// Load the manifest and all archives
	FLocTextHelper LocTextHelper(SourcePath, ManifestName, ArchiveName, NativeCultureName, CulturesToGenerate, GatherManifestHelper->GetLocFileNotifies(), GatherManifestHelper->GetPlatformSplitMode());
	LocTextHelper.SetCopyrightNotice(GatherManifestHelper->GetCopyrightNotice());
	{
		FText LoadError;
		if (!LocTextHelper.LoadAll(ELocTextHelperLoadFlags::LoadOrCreate, &LoadError))
		{
			UE_LOG(LogGenerateTextLocalizationResourceCommandlet, Error, TEXT("%s"), *LoadError.ToString());

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/ImportDialogueScriptCommandlet.cpp:103

Scope (from outer to inner):

file
function     int32 UImportDialogueScriptCommandlet::Main

Source code excerpt:


	// Get the manifest name
	FString ManifestName;
	if (!GetStringFromConfig(*SectionName, TEXT("ManifestName"), ManifestName, ConfigPath))
	{
		UE_LOG(LogImportDialogueScriptCommandlet, Error, TEXT("No manifest name specified."));
		return -1;
	}

	// Get the archive name

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/ImportDialogueScriptCommandlet.cpp:134

Scope (from outer to inner):

file
function     int32 UImportDialogueScriptCommandlet::Main

Source code excerpt:


	// Load the manifest and all archives
	FLocTextHelper LocTextHelper(DestinationPath, ManifestName, ArchiveName, NativeCulture, CulturesToGenerate, GatherManifestHelper->GetLocFileNotifies(), GatherManifestHelper->GetPlatformSplitMode());
	LocTextHelper.SetCopyrightNotice(GatherManifestHelper->GetCopyrightNotice());
	{
		FText LoadError;
		if (!LocTextHelper.LoadAll(ELocTextHelperLoadFlags::LoadOrCreate, &LoadError))
		{
			UE_LOG(LogImportDialogueScriptCommandlet, Error, TEXT("%s"), *LoadError.ToString());

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/ImportLocalizedDialogueCommandlet.cpp:87

Scope (from outer to inner):

file
function     int32 UImportLocalizedDialogueCommandlet::Main

Source code excerpt:


	// Get the manifest name
	FString ManifestName;
	if (!GetStringFromConfig(*SectionName, TEXT("ManifestName"), ManifestName, ConfigPath))
	{
		UE_LOG(LogImportLocalizedDialogueCommandlet, Error, TEXT("No manifest name specified."));
		return -1;
	}

	// Get the archive name

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/ImportLocalizedDialogueCommandlet.cpp:136

Scope (from outer to inner):

file
function     int32 UImportLocalizedDialogueCommandlet::Main

Source code excerpt:


	// Load the manifest and all archives
	FLocTextHelper LocTextHelper(SourcePath, ManifestName, ArchiveName, NativeCulture, CulturesToGenerate, GatherManifestHelper->GetLocFileNotifies(), GatherManifestHelper->GetPlatformSplitMode());
	LocTextHelper.SetCopyrightNotice(GatherManifestHelper->GetCopyrightNotice());
	{
		FText LoadError;
		if (!LocTextHelper.LoadAll(ELocTextHelperLoadFlags::LoadOrCreate, &LoadError))
		{
			UE_LOG(LogImportLocalizedDialogueCommandlet, Error, TEXT("%s"), *LoadError.ToString());

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/InternationalizationConditioningCommandlet.cpp:308

Scope (from outer to inner):

file
function     bool UInternationalizationConditioningCommandlet::ProcessManifest

Source code excerpt:

bool UInternationalizationConditioningCommandlet::ProcessManifest( const FString& PrimaryLangExt, const FString& SourcePath, const FString& DestinationPath )
{
	FString ManifestName = TEXT("Manifest.txt");

	GetStringFromConfig( *SectionName, TEXT("ManifestName"), ManifestName, GatherTextConfigPath );

	// Build info about the primary language
	TArray<FString> PrimaryFilenames;
	TArray<FString> PathPrimaryFilenames;
	FString PrimaryLocDirectory = SourcePath / PrimaryLangExt + TEXT("/");
	FString PrimaryWildcardName = PrimaryLocDirectory + TEXT("*.") + PrimaryLangExt;

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/InternationalizationConditioningCommandlet.cpp:349

Scope (from outer to inner):

file
function     bool UInternationalizationConditioningCommandlet::ProcessManifest

Source code excerpt:

	TSharedRef< FInternationalizationManifest > InternationalizationManifest = MakeShareable( new FInternationalizationManifest );

	FString ExistingManifestFileName = DestinationPath / ManifestName;

	if( FPaths::FileExists(ExistingManifestFileName) )
	{
		FJsonInternationalizationManifestSerializer::DeserializeManifestFromFile( ExistingManifestFileName, InternationalizationManifest );
	}

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/InternationalizationConditioningCommandlet.cpp:374

Scope (from outer to inner):

file
function     bool UInternationalizationConditioningCommandlet::ProcessManifest

Source code excerpt:

	}

	FString DestinationManifestFileName = DestinationPath / ManifestName;
	const bool bDidWriteManifest = FLocalizedAssetSCCUtil::SaveFileWithSCC(SourceControlInfo, DestinationManifestFileName, [&InternationalizationManifest](const FString& InSaveFileName) -> bool
	{
		return FJsonInternationalizationManifestSerializer::SerializeManifestToFile(InternationalizationManifest, InSaveFileName);
	});

	if (!bDidWriteManifest)

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/InternationalizationExportCommandlet.cpp:61

Scope (from outer to inner):

file
function     int32 UInternationalizationExportCommandlet::Main

Source code excerpt:


	// Get manifest name.
	FString ManifestName;
	if (!GetStringFromConfig(*SectionName, TEXT("ManifestName"), ManifestName, ConfigPath))
	{
		UE_LOG(LogInternationalizationExportCommandlet, Error, TEXT("No manifest name specified."));
		return false;
	}

	// Get archive name.

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/InternationalizationExportCommandlet.cpp:160

Scope (from outer to inner):

file
function     int32 UInternationalizationExportCommandlet::Main

Source code excerpt:

	{
		// Load the manifest and all archives
		FLocTextHelper LocTextHelper(DestinationPath, ManifestName, ArchiveName, NativeCultureName, CulturesToGenerate, GatherManifestHelper->GetLocFileNotifies(), GatherManifestHelper->GetPlatformSplitMode());
		LocTextHelper.SetCopyrightNotice(GatherManifestHelper->GetCopyrightNotice());
		{
			FText LoadError;
			if (!LocTextHelper.LoadAll(ELocTextHelperLoadFlags::LoadOrCreate, &LoadError))
			{
				UE_LOG(LogInternationalizationExportCommandlet, Error, TEXT("%s"), *LoadError.ToString());

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/Commandlets/InternationalizationExportCommandlet.cpp:185

Scope (from outer to inner):

file
function     int32 UInternationalizationExportCommandlet::Main

Source code excerpt:


		// Load the manifest and all archives
		FLocTextHelper LocTextHelper(SourcePath, ManifestName, ArchiveName, NativeCultureName, CulturesToGenerate, GatherManifestHelper->GetLocFileNotifies(), GatherManifestHelper->GetPlatformSplitMode());
		LocTextHelper.SetCopyrightNotice(GatherManifestHelper->GetCopyrightNotice());
		{
			FText LoadError;
			if (!LocTextHelper.LoadAll(ELocTextHelperLoadFlags::LoadOrCreate, &LoadError))
			{
				UE_LOG(LogInternationalizationExportCommandlet, Error, TEXT("%s"), *LoadError.ToString());

#Loc: <Workspace>/Engine/Source/Programs/Unsync/Private/UnsyncJupiter.cpp:726

Scope (from outer to inner):

file
namespace    unsync
function     TResult<FBuffer> FJupiterProtocolImpl::DownloadManifest

Source code excerpt:


TResult<FBuffer>
FJupiterProtocolImpl::DownloadManifest(std::string_view ManifestName)
{
	// Get root manifest reference object
	std::string RefUrl = fmt::format("/api/v1/refs/{}/{}/{}.uecb", RemoteDesc.StorageNamespace, RemoteDesc.StorageBucket, ManifestName);

	FHttpResponse Response = HttpRequest(Connection,
										 EHttpMethod::GET,
										 ToStringView(RefUrl),
										 EHttpContentType::Application_UECB,
										 FBufferView{},

#Loc: <Workspace>/Engine/Source/Programs/Unsync/Private/UnsyncJupiter.h:40

Scope (from outer to inner):

file
namespace    unsync

Source code excerpt:

						 std::string_view		   HttpHeaders);
	virtual bool			 IsValid() const override;
	virtual TResult<FBuffer> DownloadManifest(std::string_view ManifestName) override;
	virtual FDownloadResult	 Download(const TArrayView<FNeedBlock> NeedBlocks, const FBlockDownloadCallback& CompletionCallback) override;
	virtual void			 Invalidate() override;
	virtual bool			 Contains(const FDirectoryManifest& Manifest) override;

	FHttpConnection Connection;
	std::string		HttpHeaders;  // TODO: store this in the HttpConnection instead

#Loc: <Workspace>/Engine/Source/Programs/Unsync/Private/UnsyncProxy.cpp:24

Scope (from outer to inner):

file
namespace    unsync
function     virtual TResult<FBuffer> DownloadManifest

Source code excerpt:

	virtual bool			 IsValid() const override;
	virtual FDownloadResult	 Download(const TArrayView<FNeedBlock> NeedBlocks, const FBlockDownloadCallback& CompletionCallback) override;
	virtual TResult<FBuffer> DownloadManifest(std::string_view ManifestName) override
	{
		return AppError(L"Manifests can't be downloaded from UNSYNC proxy.");
	};
	virtual void Invalidate() override;
	virtual bool Contains(const FDirectoryManifest& Manifest) override { return true; }	 // TODO: check files on the unsync proxy

#Loc: <Workspace>/Engine/Source/Programs/Unsync/Private/UnsyncProxy.cpp:189

Scope (from outer to inner):

file
namespace    unsync
function     TResult<FBuffer> FProxy::DownloadManifest

Source code excerpt:


TResult<FBuffer>
FProxy::DownloadManifest(std::string_view ManifestName)
{
	if (ProtocolImpl.get())
	{
		return ProtocolImpl->DownloadManifest(ManifestName);
	}
	else
	{
		return AppError(L"Server connection is invalid");
	}
}

#Loc: <Workspace>/Engine/Source/Programs/Unsync/Private/UnsyncProxy.h:127

Scope (from outer to inner):

file
namespace    unsync

Source code excerpt:


	virtual FDownloadResult	 Download(const TArrayView<FNeedBlock> NeedBlocks, const FBlockDownloadCallback& CompletionCallback) = 0;
	virtual TResult<FBuffer> DownloadManifest(std::string_view ManifestName)													 = 0;

	const FBlockRequestMap* RequestMap;
	FRemoteDesc				RemoteDesc;
};

// TODO:

#Loc: <Workspace>/Engine/Source/Programs/Unsync/Private/UnsyncProxy.h:149

Scope (from outer to inner):

file
namespace    unsync
class        class FProxy

Source code excerpt:


	FDownloadResult	 Download(const TArrayView<FNeedBlock> NeedBlocks, const FBlockDownloadCallback& CompletionCallback);
	TResult<FBuffer> DownloadManifest(std::string_view ManifestName);

private:
	std::unique_ptr<FRemoteProtocolBase> ProtocolImpl;
};

class FProxyPool

#References in C# build files

This variable is referenced in the following C# build files:

Location: <Workspace>/Engine/Source/Programs/AutomationTool/Scripts/Localisation.Automation.cs:1007


		string ManifestName;
		if (!LocalizationConfig.GetString("CommonSettings", "ManifestName", out ManifestName))
		{
			throw new AutomationException("Failed to find a required config key! Section: 'CommonSettings', Key: 'ManifestName', File: '{0}'", LocalizationConfigFile);
		}

		string ArchiveName;
		if (!LocalizationConfig.GetString("CommonSettings", "ArchiveName", out ArchiveName))