| public GetStringField ( string FieldName ) : string | ||
| FieldName | string | |
| return | string | |
/// <summary>
/// Constructs a ModuleDescriptor from a Json object
/// </summary>
/// <param name="InObject"></param>
/// <returns>The new module descriptor</returns>
public static ModuleDescriptor FromJsonObject(JsonObject InObject)
{
ModuleDescriptor Module = new ModuleDescriptor(InObject.GetStringField("Name"), InObject.GetEnumField <ModuleHostType>("Type"));
ModuleLoadingPhase LoadingPhase;
if (InObject.TryGetEnumField <ModuleLoadingPhase>("LoadingPhase", out LoadingPhase))
{
Module.LoadingPhase = LoadingPhase;
}
UnrealTargetPlatform[] WhitelistPlatforms;
if (InObject.TryGetEnumArrayField <UnrealTargetPlatform>("WhitelistPlatforms", out WhitelistPlatforms))
{
Module.WhitelistPlatforms = WhitelistPlatforms;
}
UnrealTargetPlatform[] BlacklistPlatforms;
if (InObject.TryGetEnumArrayField <UnrealTargetPlatform>("BlacklistPlatforms", out BlacklistPlatforms))
{
Module.BlacklistPlatforms = BlacklistPlatforms;
}
string[] AdditionalDependencies;
if (InObject.TryGetStringArrayField("AdditionalDependencies", out AdditionalDependencies))
{
Module.AdditionalDependencies = AdditionalDependencies;
}
return(Module);
}
/// <summary>
/// Construct a PluginReferenceDescriptor from a Json object
/// </summary>
/// <param name="RawObject">The Json object containing a plugin reference descriptor</param>
/// <returns>New PluginReferenceDescriptor object</returns>
public static PluginReferenceDescriptor FromJsonObject(JsonObject RawObject)
{
PluginReferenceDescriptor Descriptor = new PluginReferenceDescriptor(RawObject.GetStringField("Name"), null, RawObject.GetBoolField("Enabled"));
RawObject.TryGetStringField("Description", out Descriptor.Description);
RawObject.TryGetStringField("MarketplaceURL", out Descriptor.MarketplaceURL);
RawObject.TryGetEnumArrayField <UnrealTargetPlatform>("WhitelistPlatforms", out Descriptor.WhitelistPlatforms);
RawObject.TryGetEnumArrayField <UnrealTargetPlatform>("BlacklistPlatforms", out Descriptor.BlacklistPlatforms);
return(Descriptor);
}
/// <summary>
/// Read an app receipt from disk
/// </summary>
/// <param name="FileName">Filename to read from</param>
/// <returns>The receipt that was read</returns>
public static ModuleManifest Read(FileReference FileName)
{
JsonObject Object = JsonObject.Read(FileName);
ModuleManifest Receipt = new ModuleManifest(Object.GetStringField("BuildId"));
JsonObject Modules = Object.GetObjectField("Modules");
foreach (string ModuleName in Modules.KeyNames)
{
Receipt.ModuleNameToFileName.Add(ModuleName, Modules.GetStringField(ModuleName));
}
return(Receipt);
}
/// <summary>
/// Read an app receipt from disk
/// </summary>
/// <param name="FileName">Filename to read from</param>
/// <returns>The receipt that was read</returns>
public static VersionManifest Read(string FileName)
{
JsonObject Object = JsonObject.Read(FileName);
VersionManifest Receipt = new VersionManifest(Object.GetIntegerField("Changelist"), Object.GetStringField("BuildId"));
JsonObject Modules = Object.GetObjectField("Modules");
foreach (string ModuleName in Modules.KeyNames)
{
Receipt.ModuleNameToFileName.Add(ModuleName, Modules.GetStringField(ModuleName));
}
return(Receipt);
}
/// <summary>
/// Construct a PluginReferenceDescriptor from a Json object
/// </summary>
/// <param name="RawObject">The Json object containing a plugin reference descriptor</param>
/// <returns>New PluginReferenceDescriptor object</returns>
public static PluginReferenceDescriptor FromJsonObject(JsonObject RawObject)
{
string[] WhitelistPlatformNames = null;
string[] BlacklistPlatformNames = null;
string[] SupportedTargetPlatformNames = null;
PluginReferenceDescriptor Descriptor = new PluginReferenceDescriptor(RawObject.GetStringField("Name"), null, RawObject.GetBoolField("Enabled"));
RawObject.TryGetBoolField("Optional", out Descriptor.bOptional);
RawObject.TryGetStringField("Description", out Descriptor.Description);
RawObject.TryGetStringField("MarketplaceURL", out Descriptor.MarketplaceURL);
// Only parse platform information if enabled
if (Descriptor.bEnabled)
{
RawObject.TryGetStringArrayField("WhitelistPlatforms", out WhitelistPlatformNames);
RawObject.TryGetStringArrayField("BlacklistPlatforms", out BlacklistPlatformNames);
RawObject.TryGetEnumArrayField <UnrealTargetConfiguration>("WhitelistTargetConfigurations", out Descriptor.WhitelistTargetConfigurations);
RawObject.TryGetEnumArrayField <UnrealTargetConfiguration>("BlacklistTargetConfigurations", out Descriptor.BlacklistTargetConfigurations);
RawObject.TryGetEnumArrayField <TargetType>("WhitelistTargets", out Descriptor.WhitelistTargets);
RawObject.TryGetEnumArrayField <TargetType>("BlacklistTargets", out Descriptor.BlacklistTargets);
RawObject.TryGetStringArrayField("SupportedTargetPlatforms", out SupportedTargetPlatformNames);
}
try
{
// convert string array to UnrealTargetPlatform arrays
if (WhitelistPlatformNames != null)
{
Descriptor.WhitelistPlatforms = WhitelistPlatformNames.Select(x => UnrealTargetPlatform.Parse(x)).ToList();
}
if (BlacklistPlatformNames != null)
{
Descriptor.BlacklistPlatforms = BlacklistPlatformNames.Select(x => UnrealTargetPlatform.Parse(x)).ToList();
}
if (SupportedTargetPlatformNames != null)
{
Descriptor.SupportedTargetPlatforms = SupportedTargetPlatformNames.Select(x => UnrealTargetPlatform.Parse(x)).ToList();
}
}
catch (BuildException Ex)
{
ExceptionUtils.AddContext(Ex, "while parsing PluginReferenceDescriptor {0}", Descriptor.Name);
throw;
}
return(Descriptor);
}
/// <summary>
/// Imports an action graph from a JSON file
/// </summary>
/// <param name="InputFile">The file to read from</param>
/// <returns>List of actions</returns>
public static List <Action> ImportJson(FileReference InputFile)
{
JsonObject Object = JsonObject.Read(InputFile);
JsonObject EnvironmentObject = Object.GetObjectField("Environment");
foreach (string KeyName in EnvironmentObject.KeyNames)
{
Environment.SetEnvironmentVariable(KeyName, EnvironmentObject.GetStringField(KeyName));
}
List <Action> Actions = new List <Action>();
foreach (JsonObject ActionObject in Object.GetObjectArrayField("Actions"))
{
Actions.Add(Action.ImportJson(ActionObject));
}
return(Actions);
}
/// <summary>
/// Read an app receipt from disk
/// </summary>
/// <param name="FileName">Filename to read from</param>
/// <returns>The receipt that was read</returns>
public static VersionManifest Read(string FileName)
{
JsonObject Object = JsonObject.Read(FileName);
int Changelist = Object.GetIntegerField("Changelist");
int CompatibleChangelist;
if (!Object.TryGetIntegerField("CompatibleChangelist", out CompatibleChangelist))
{
CompatibleChangelist = Changelist;
}
VersionManifest Receipt = new VersionManifest(Changelist, CompatibleChangelist, Object.GetStringField("BuildId"));
JsonObject Modules = Object.GetObjectField("Modules");
foreach (string ModuleName in Modules.KeyNames)
{
Receipt.ModuleNameToFileName.Add(ModuleName, Modules.GetStringField(ModuleName));
}
return(Receipt);
}
/// <summary>
/// Checks to see if the assembly needs compilation
/// </summary>
/// <param name="SourceFiles">Set of source files</param>
/// <param name="AssemblyManifestFilePath">File containing information about this assembly, like which source files it was built with and engine version</param>
/// <param name="OutputAssemblyPath">Output path for the assembly</param>
/// <returns>True if the assembly needs to be built</returns>
private static bool RequiresCompilation(HashSet <FileReference> SourceFiles, FileReference AssemblyManifestFilePath, FileReference OutputAssemblyPath)
{
// Check to see if we already have a compiled assembly file on disk
FileItem OutputAssemblyInfo = FileItem.GetItemByFileReference(OutputAssemblyPath);
if (!OutputAssemblyInfo.Exists)
{
Log.TraceLog("Compiling {0}: Assembly does not exist", OutputAssemblyPath);
return(true);
}
// Check the time stamp of the UnrealBuildTool.exe file. If Unreal Build Tool was compiled more
// recently than the dynamically-compiled assembly, then we'll always recompile it. This is
// because Unreal Build Tool's code may have changed in such a way that invalidate these
// previously-compiled assembly files.
FileItem ExecutableItem = FileItem.GetItemByFileReference(UnrealBuildTool.GetUBTPath());
if (ExecutableItem.LastWriteTimeUtc > OutputAssemblyInfo.LastWriteTimeUtc)
{
Log.TraceLog("Compiling {0}: {1} is newer", OutputAssemblyPath, ExecutableItem.Name);
return(true);
}
// Make sure we have a manifest of source files used to compile the output assembly. If it doesn't exist
// for some reason (not an expected case) then we'll need to recompile.
FileItem AssemblySourceListFile = FileItem.GetItemByFileReference(AssemblyManifestFilePath);
if (!AssemblySourceListFile.Exists)
{
Log.TraceLog("Compiling {0}: Missing source file list ({1})", OutputAssemblyPath, AssemblyManifestFilePath);
return(true);
}
JsonObject Manifest = JsonObject.Read(AssemblyManifestFilePath);
// check if the engine version is different
string EngineVersionManifest = Manifest.GetStringField("EngineVersion");
string EngineVersionCurrent = FormatVersionNumber(ReadOnlyBuildVersion.Current);
if (EngineVersionManifest != EngineVersionCurrent)
{
Log.TraceLog("Compiling {0}: Engine Version changed from {1} to {2}", OutputAssemblyPath, EngineVersionManifest, EngineVersionCurrent);
return(true);
}
// Make sure the source files we're compiling are the same as the source files that were compiled
// for the assembly that we want to load
HashSet <FileItem> CurrentSourceFileItems = new HashSet <FileItem>();
foreach (string Line in Manifest.GetStringArrayField("SourceFiles"))
{
CurrentSourceFileItems.Add(FileItem.GetItemByPath(Line));
}
// Get the new source files
HashSet <FileItem> SourceFileItems = new HashSet <FileItem>();
foreach (FileReference SourceFile in SourceFiles)
{
SourceFileItems.Add(FileItem.GetItemByFileReference(SourceFile));
}
// Check if there are any differences between the sets
foreach (FileItem CurrentSourceFileItem in CurrentSourceFileItems)
{
if (!SourceFileItems.Contains(CurrentSourceFileItem))
{
Log.TraceLog("Compiling {0}: Removed source file ({1})", OutputAssemblyPath, CurrentSourceFileItem);
return(true);
}
}
foreach (FileItem SourceFileItem in SourceFileItems)
{
if (!CurrentSourceFileItems.Contains(SourceFileItem))
{
Log.TraceLog("Compiling {0}: Added source file ({1})", OutputAssemblyPath, SourceFileItem);
return(true);
}
}
// Check if any of the timestamps are newer
foreach (FileItem SourceFileItem in SourceFileItems)
{
if (SourceFileItem.LastWriteTimeUtc > OutputAssemblyInfo.LastWriteTimeUtc)
{
Log.TraceLog("Compiling {0}: {1} is newer", OutputAssemblyPath, SourceFileItem);
return(true);
}
}
return(false);
}
/// <summary>
/// Read a receipt from disk.
/// </summary>
/// <param name="Location">Filename to read from</param>
/// <param name="EngineDir">Engine directory for expanded variables</param>
public static TargetReceipt Read(FileReference Location, DirectoryReference EngineDir)
{
JsonObject RawObject = JsonObject.Read(Location);
// Read the initial fields
string TargetName = RawObject.GetStringField("TargetName");
TargetType TargetType = RawObject.GetEnumField <TargetType>("TargetType");
UnrealTargetPlatform Platform = UnrealTargetPlatform.Parse(RawObject.GetStringField("Platform"));
UnrealTargetConfiguration Configuration = RawObject.GetEnumField <UnrealTargetConfiguration>("Configuration");
// Try to read the build version
BuildVersion Version;
if (!BuildVersion.TryParse(RawObject.GetObjectField("Version"), out Version))
{
throw new JsonParseException("Invalid 'Version' field");
}
// Read the project path
FileReference ProjectFile;
string RelativeProjectFile;
if (RawObject.TryGetStringField("Project", out RelativeProjectFile))
{
ProjectFile = FileReference.Combine(Location.Directory, RelativeProjectFile);
}
else
{
ProjectFile = null;
}
// Create the receipt
TargetReceipt Receipt = new TargetReceipt(ProjectFile, TargetName, TargetType, Platform, Configuration, Version);
// Get the project directory
DirectoryReference ProjectDir = Receipt.ProjectDir;
// Read the launch executable
string Launch;
if (RawObject.TryGetStringField("Launch", out Launch))
{
Receipt.Launch = ExpandPathVariables(Launch, EngineDir, ProjectDir);
}
// Read the build products
JsonObject[] BuildProductObjects;
if (RawObject.TryGetObjectArrayField("BuildProducts", out BuildProductObjects))
{
foreach (JsonObject BuildProductObject in BuildProductObjects)
{
string Path;
BuildProductType Type;
if (BuildProductObject.TryGetStringField("Path", out Path) && BuildProductObject.TryGetEnumField("Type", out Type))
{
FileReference File = ExpandPathVariables(Path, EngineDir, ProjectDir);
string Module;
BuildProductObject.TryGetStringField("Module", out Module);
Receipt.AddBuildProduct(File, Type);
}
}
}
// Read the runtime dependencies
JsonObject[] RuntimeDependencyObjects;
if (RawObject.TryGetObjectArrayField("RuntimeDependencies", out RuntimeDependencyObjects))
{
foreach (JsonObject RuntimeDependencyObject in RuntimeDependencyObjects)
{
string Path;
if (RuntimeDependencyObject.TryGetStringField("Path", out Path))
{
FileReference File = ExpandPathVariables(Path, EngineDir, ProjectDir);
StagedFileType Type;
if (!RuntimeDependencyObject.TryGetEnumField("Type", out Type))
{
// Previous format included an optional IgnoreIfMissing flag, which was only used for debug files. We can explicitly reference them as DebugNonUFS files now.
bool bIgnoreIfMissing;
if (RuntimeDependencyObject.TryGetBoolField("IgnoreIfMissing", out bIgnoreIfMissing))
{
bIgnoreIfMissing = false;
}
Type = bIgnoreIfMissing? StagedFileType.DebugNonUFS : StagedFileType.NonUFS;
}
Receipt.RuntimeDependencies.Add(File, Type);
}
}
}
// Read the additional properties
JsonObject[] AdditionalPropertyObjects;
if (RawObject.TryGetObjectArrayField("AdditionalProperties", out AdditionalPropertyObjects))
{
foreach (JsonObject AdditionalPropertyObject in AdditionalPropertyObjects)
{
string Name;
if (AdditionalPropertyObject.TryGetStringField("Name", out Name))
{
string Value;
if (AdditionalPropertyObject.TryGetStringField("Value", out Value))
{
Receipt.AdditionalProperties.Add(new ReceiptProperty(Name, Value));
}
}
}
}
return(Receipt);
}
/// <summary>
/// Read a receipt from disk.
/// </summary>
/// <param name="FileName">Filename to read from</param>
public static TargetReceipt Read(string FileName)
{
JsonObject RawObject = JsonObject.Read(FileName);
// Read the initial fields
string TargetName = RawObject.GetStringField("TargetName");
UnrealTargetPlatform Platform = RawObject.GetEnumField <UnrealTargetPlatform>("Platform");
UnrealTargetConfiguration Configuration = RawObject.GetEnumField <UnrealTargetConfiguration>("Configuration");
string BuildId = RawObject.GetStringField("BuildId");
// Try to read the build version
BuildVersion Version;
if (!BuildVersion.TryParse(RawObject.GetObjectField("Version"), out Version))
{
throw new JsonParseException("Invalid 'Version' field");
}
// Create the receipt
TargetReceipt Receipt = new TargetReceipt(TargetName, Platform, Configuration, BuildId, Version);
// Read the build products
JsonObject[] BuildProductObjects;
if (RawObject.TryGetObjectArrayField("BuildProducts", out BuildProductObjects))
{
foreach (JsonObject BuildProductObject in BuildProductObjects)
{
string Path;
BuildProductType Type;
if (BuildProductObject.TryGetStringField("Path", out Path) && BuildProductObject.TryGetEnumField("Type", out Type))
{
string Module;
BuildProductObject.TryGetStringField("Module", out Module);
BuildProduct NewBuildProduct = Receipt.AddBuildProduct(Path, Type);
bool IsPrecompiled;
if (BuildProductObject.TryGetBoolField("IsPrecompiled", out IsPrecompiled))
{
NewBuildProduct.IsPrecompiled = IsPrecompiled;
}
}
}
}
// Read the runtime dependencies
JsonObject[] RuntimeDependencyObjects;
if (RawObject.TryGetObjectArrayField("RuntimeDependencies", out RuntimeDependencyObjects))
{
foreach (JsonObject RuntimeDependencyObject in RuntimeDependencyObjects)
{
string Path;
if (RuntimeDependencyObject.TryGetStringField("Path", out Path))
{
StagedFileType Type;
if (!RuntimeDependencyObject.TryGetEnumField("Type", out Type))
{
// Previous format included an optional IgnoreIfMissing flag, which was only used for debug files. We can explicitly reference them as DebugNonUFS files now.
bool bIgnoreIfMissing;
if (RuntimeDependencyObject.TryGetBoolField("IgnoreIfMissing", out bIgnoreIfMissing))
{
bIgnoreIfMissing = false;
}
Type = bIgnoreIfMissing? StagedFileType.DebugNonUFS : StagedFileType.NonUFS;
}
Receipt.RuntimeDependencies.Add(Path, Type);
}
}
}
// Read the additional properties
JsonObject[] AdditionalPropertyObjects;
if (RawObject.TryGetObjectArrayField("AdditionalProperties", out AdditionalPropertyObjects))
{
foreach (JsonObject AdditionalPropertyObject in AdditionalPropertyObjects)
{
string Name;
if (AdditionalPropertyObject.TryGetStringField("Name", out Name))
{
string Value;
if (AdditionalPropertyObject.TryGetStringField("Value", out Value))
{
Receipt.AdditionalProperties.Add(new ReceiptProperty(Name, Value));
}
}
}
}
// Read the precompiled dependencies
string[] PrecompiledBuildDependencies;
if (RawObject.TryGetStringArrayField("PrecompiledBuildDependencies", out PrecompiledBuildDependencies))
{
Receipt.PrecompiledBuildDependencies.UnionWith(PrecompiledBuildDependencies);
}
// Read the precompiled dependencies
string[] PrecompiledRuntimeDependencies;
if (RawObject.TryGetStringArrayField("PrecompiledRuntimeDependencies", out PrecompiledRuntimeDependencies))
{
Receipt.PrecompiledRuntimeDependencies.UnionWith(PrecompiledRuntimeDependencies);
}
return(Receipt);
}
/// <summary>
/// Constructs a LocalizationTargetDescriptor from a Json object
/// </summary>
/// <param name="InObject"></param>
/// <returns>The new localization target descriptor</returns>
public static LocalizationTargetDescriptor FromJsonObject(JsonObject InObject)
{
return(new LocalizationTargetDescriptor(InObject.GetStringField("Name"), InObject.GetEnumField <LocalizationTargetDescriptorLoadingPolicy>("LoadingPolicy")));
}
/// <summary>
/// Constructs a ModuleDescriptor from a Json object
/// </summary>
/// <param name="InObject"></param>
/// <returns>The new module descriptor</returns>
public static ModuleDescriptor FromJsonObject(JsonObject InObject)
{
ModuleDescriptor Module = new ModuleDescriptor(InObject.GetStringField("Name"), InObject.GetEnumField <ModuleHostType>("Type"));
ModuleLoadingPhase LoadingPhase;
if (InObject.TryGetEnumField <ModuleLoadingPhase>("LoadingPhase", out LoadingPhase))
{
Module.LoadingPhase = LoadingPhase;
}
try
{
string[] WhitelistPlatforms;
if (InObject.TryGetStringArrayField("WhitelistPlatforms", out WhitelistPlatforms))
{
Module.WhitelistPlatforms = Array.ConvertAll(WhitelistPlatforms, x => UnrealTargetPlatform.Parse(x));
}
string[] BlacklistPlatforms;
if (InObject.TryGetStringArrayField("BlacklistPlatforms", out BlacklistPlatforms))
{
Module.BlacklistPlatforms = Array.ConvertAll(BlacklistPlatforms, x => UnrealTargetPlatform.Parse(x));
}
}
catch (BuildException Ex)
{
ExceptionUtils.AddContext(Ex, "while parsing module descriptor '{0}'", Module.Name);
throw;
}
TargetType[] WhitelistTargets;
if (InObject.TryGetEnumArrayField <TargetType>("WhitelistTargets", out WhitelistTargets))
{
Module.WhitelistTargets = WhitelistTargets;
}
TargetType[] BlacklistTargets;
if (InObject.TryGetEnumArrayField <TargetType>("BlacklistTargets", out BlacklistTargets))
{
Module.BlacklistTargets = BlacklistTargets;
}
UnrealTargetConfiguration[] WhitelistTargetConfigurations;
if (InObject.TryGetEnumArrayField <UnrealTargetConfiguration>("WhitelistTargetConfigurations", out WhitelistTargetConfigurations))
{
Module.WhitelistTargetConfigurations = WhitelistTargetConfigurations;
}
UnrealTargetConfiguration[] BlacklistTargetConfigurations;
if (InObject.TryGetEnumArrayField <UnrealTargetConfiguration>("BlacklistTargetConfigurations", out BlacklistTargetConfigurations))
{
Module.BlacklistTargetConfigurations = BlacklistTargetConfigurations;
}
string[] WhitelistPrograms;
if (InObject.TryGetStringArrayField("WhitelistPrograms", out WhitelistPrograms))
{
Module.WhitelistPrograms = WhitelistPrograms;
}
string[] BlacklistPrograms;
if (InObject.TryGetStringArrayField("BlacklistPrograms", out BlacklistPrograms))
{
Module.BlacklistPrograms = BlacklistPrograms;
}
string[] AdditionalDependencies;
if (InObject.TryGetStringArrayField("AdditionalDependencies", out AdditionalDependencies))
{
Module.AdditionalDependencies = AdditionalDependencies;
}
return(Module);
}
/// <summary>
/// Read a receipt from disk.
/// </summary>
/// <param name="FileName">Filename to read from</param>
public static TargetReceipt Read(string FileName)
{
JsonObject RawObject = JsonObject.Read(FileName);
// Read the initial fields
string TargetName = RawObject.GetStringField("TargetName");
UnrealTargetPlatform Platform = RawObject.GetEnumField <UnrealTargetPlatform>("Platform");
UnrealTargetConfiguration Configuration = RawObject.GetEnumField <UnrealTargetConfiguration>("Configuration");
string BuildId = RawObject.GetStringField("BuildId");
// Try to read the build version
BuildVersion Version;
if (!BuildVersion.TryParse(RawObject.GetObjectField("Version"), out Version))
{
throw new JsonParseException("Invalid 'Version' field");
}
// Create the receipt
TargetReceipt Receipt = new TargetReceipt(TargetName, Platform, Configuration, BuildId, Version);
// Read the build products
JsonObject[] BuildProductObjects;
if (RawObject.TryGetObjectArrayField("BuildProducts", out BuildProductObjects))
{
foreach (JsonObject BuildProductObject in BuildProductObjects)
{
string Path;
BuildProductType Type;
if (BuildProductObject.TryGetStringField("Path", out Path) && BuildProductObject.TryGetEnumField("Type", out Type))
{
string Module;
BuildProductObject.TryGetStringField("Module", out Module);
BuildProduct NewBuildProduct = Receipt.AddBuildProduct(Path, Type);
bool IsPrecompiled;
if (BuildProductObject.TryGetBoolField("IsPrecompiled", out IsPrecompiled))
{
NewBuildProduct.IsPrecompiled = IsPrecompiled;
}
}
}
}
// Read the runtime dependencies
JsonObject[] RuntimeDependencyObjects;
if (RawObject.TryGetObjectArrayField("RuntimeDependencies", out RuntimeDependencyObjects))
{
foreach (JsonObject RuntimeDependencyObject in RuntimeDependencyObjects)
{
string Path;
if (RuntimeDependencyObject.TryGetStringField("Path", out Path))
{
string StagePath;
if (!RuntimeDependencyObject.TryGetStringField("StagePath", out StagePath))
{
StagePath = null;
}
bool bIgnoreIfMissing;
if (!RuntimeDependencyObject.TryGetBoolField("IgnoreIfMissing", out bIgnoreIfMissing))
{
bIgnoreIfMissing = false;
}
Receipt.AddRuntimeDependency(Path, StagePath, bIgnoreIfMissing);
}
}
}
// Read the additional properties
JsonObject[] AdditionalPropertyObjects;
if (RawObject.TryGetObjectArrayField("AdditionalProperties", out AdditionalPropertyObjects))
{
foreach (JsonObject AdditionalPropertyObject in AdditionalPropertyObjects)
{
string Name;
if (AdditionalPropertyObject.TryGetStringField("Name", out Name))
{
string Value;
if (AdditionalPropertyObject.TryGetStringField("Value", out Value))
{
Receipt.AdditionalProperties.Add(new ReceiptProperty(Name, Value));
}
}
}
}
return(Receipt);
}
