private System.Exception UpdateFilePath(string filePath, bool forceUpdate)
{
#if REPORT_PERFORMANCE
System.Diagnostics.Debug.WriteLine(">>>> ENTER Fork.UpdateFilePath(" + filePath + "," + forceUpdate + ") + T:" + System.Threading.Thread.CurrentThread.ManagedThreadId);
var stopwatch = System.Diagnostics.Stopwatch.StartNew();
try
{
#endif // REPORT_PERFORMANCE
System.Exception error = null;
if ((FileSystem != null) && FileSystem.Frozen)
{
// During save, do not attempt to regenerate contents.
return(error);
}
try
{
// Do some special work if this is a ROM fork.
if ((FileSystem != null) && (FileSystem.GetForkKind(this) == ForkKind.Program))
{
if (forceUpdate)
{
#if REPORT_PERFORMANCE
System.Diagnostics.Debug.WriteLine(">>>>>> ENTER Fork.UpdateFilePath(forceUpdate): GetRom");
var stopwatch2 = System.Diagnostics.Stopwatch.StartNew();
try
{
#endif // REPORT_PERFORMANCE
var filesUsingFork = FileSystem.GetFilesUsingForks(new[] { this }).Values;
foreach (var program in filesUsingFork.OfType <Program>())
{
// Since "Program" entries using the same Fork will all point to this one,
// we don't need to re-do this work for every file that might point at the fork.
var rom = program.Description.GetRom();
if ((rom != null) && !string.IsNullOrEmpty(rom.RomPath))
{
var path = string.Empty;
#if REPORT_PERFORMANCE
var stopwatch3 = System.Diagnostics.Stopwatch.StartNew();
#endif // REPORT_PERFORMANCE
path = rom.PrepareForDeployment(LuigiGenerationMode.Standard);
#if REPORT_PERFORMANCE
stopwatch3.Stop();
AccumulatedUpdateFilePathForcedPrepareTime += stopwatch3.Elapsed;
#endif // REPORT_PERFORMANCE
UpdateFilePath(path);
}
}
#if REPORT_PERFORMANCE
}
finally
{
stopwatch2.Stop();
System.Diagnostics.Debug.WriteLine(">>>>>> EXIT Fork.UpdateFilePath(forceUpdate): GetRom"); // took: + " + stopwatch2.Elapsed.ToString());
AccumulatedUpdateFilePathForcedTime += stopwatch2.Elapsed;
}
#endif // REPORT_PERFORMANCE
}
else
{
var rom = Rom;
var prepareForDeployment = string.IsNullOrEmpty(filePath) && (rom != null);
if (!prepareForDeployment && (rom != null))
{
// We think we don't have to prepare for deployment, but do have ROM set.
// Let's just make sure that we have that LUIGI file, shall we?
prepareForDeployment = string.IsNullOrEmpty(_filePath) || !System.IO.File.Exists(_filePath);
if (!prepareForDeployment && System.IO.File.Exists(_filePath))
{
// Check to see if it looks like a valid LUIGI file.
prepareForDeployment = LuigiFileHeader.GetHeader(_filePath) == null;
}
}
if (prepareForDeployment)
{
// No file path, but somehow we have a ROM. Force recreation of the LUIGI file. This can
// occur during sync from device.
UpdateFilePath(Rom.PrepareForDeployment(LuigiGenerationMode.Standard));
}
else if (rom == null)
{
if (!System.IO.File.Exists(filePath))
{
// No ROM, and the file we think we have does not exist.
ILfsFileInfo file;
rom = null;
if (FileSystem.GetFilesUsingForks(new[] { this }).TryGetValue(this, out file))
{
switch (FileSystem.Origin)
{
case FileSystemOrigin.HostComputer:
var description = ((Program)file).Description;
rom = description == null ? null : description.GetRom();
break;
case FileSystemOrigin.LtoFlash:
break;
}
}
prepareForDeployment = (rom != null) && !System.IO.File.Exists(filePath) && !string.IsNullOrEmpty(rom.RomPath) && System.IO.File.Exists(rom.RomPath);
if (prepareForDeployment)
{
_filePath = null;
UpdateFilePath(rom.PrepareForDeployment(LuigiGenerationMode.Standard));
}
}
// We should *always* be a LUIGI file. If not, fix it!
if (!string.IsNullOrEmpty(filePath) && System.IO.File.Exists(filePath))
{
if (!LuigiFileHeader.PotentialLuigiFile(filePath))
{
rom = INTV.Core.Model.Rom.Create(filePath, null);
prepareForDeployment = rom != null;
if (prepareForDeployment)
{
_filePath = null;
UpdateFilePath(rom.PrepareForDeployment(LuigiGenerationMode.Standard));
}
}
}
}
}
}
else
{
if (forceUpdate)
{
_filePath = null;
}
UpdateFilePath(filePath);
if (forceUpdate && !string.IsNullOrEmpty(_filePath) && !System.IO.File.Exists(_filePath))
{
error = new System.IO.FileNotFoundException("File for fork " + GlobalForkNumber + " not found.", filePath, null);
}
}
}
catch (System.IO.IOException e)
{
error = e;
if (!forceUpdate)
{
throw;
}
}
return(error);
#if REPORT_PERFORMANCE
}
finally
{
stopwatch.Stop();
System.Diagnostics.Debug.WriteLine(">>>> EXIT Fork.UpdateFilePath(" + filePath + ",force)"); // took: + " + stopwatch.Elapsed.ToString());
AccumulatedUpdateFilePathTime += stopwatch.Elapsed;
}
#endif // REPORT_PERFORMANCE
}
