public static void Serialize <TKey, TValue>(this SerializingContainer2 sc, ref OrderedMultiValueDictionary <TKey, TValue> dict, SerializeDelegate <TKey> serializeKey, SerializeDelegate <TValue> serializeValue)
{
int count = dict?.Count ?? 0;
sc.Serialize(ref count);
if (sc.IsLoading)
{
dict = new OrderedMultiValueDictionary <TKey, TValue>(count);
for (int i = 0; i < count; i++)
{
TKey key = default;
serializeKey(sc, ref key);
TValue value = default;
serializeValue(sc, ref value);
dict.Add(key, value);
}
}
else
{
for (int i = 0; i < count; i++)
{
var key = dict[i].Key;
serializeKey(sc, ref key);
var value = dict[i].Value;
serializeValue(sc, ref value);
}
}
}
private static string relinkUIndex(IMEPackage importingPCC, ExportEntry relinkingExport, ref int uIndex, string propertyName,
OrderedMultiValueDictionary <IEntry, IEntry> crossPCCObjectMappingList, string prefix, bool importExportDependencies = false)
{
if (uIndex == 0)
{
return(null); //do not relink 0
}
IMEPackage destinationPcc = relinkingExport.FileRef;
if (importingPCC == destinationPcc && uIndex < 0)
{
return(null); //do not relink same-pcc imports.
}
int sourceObjReference = uIndex;
//Debug.WriteLine($"{prefix} Relinking:{propertyName}");
if (crossPCCObjectMappingList.TryGetValue(entry => entry.UIndex == sourceObjReference, out IEntry targetEntry))
{
//relink
uIndex = targetEntry.UIndex;
//Debug.WriteLine($"{prefix} Relink hit: {sourceObjReference}{propertyName} : {targetEntry.FullPath}");
}
else if (uIndex < 0) //It's an unmapped import
{
//objProperty is currently pointing to importingPCC as that is where we read the properties from
int n = uIndex;
int origvalue = n;
//Debug.WriteLine("Relink miss, attempting JIT relink on " + n + " " + rootNode.Text);
if (importingPCC.IsImport(n))
{
//Get the original import
ImportEntry origImport = importingPCC.GetImport(n);
string origImportFullName = origImport.FullPath;
//Debug.WriteLine("We should import " + origImport.GetFullPath);
IEntry crossImport = null;
string linkFailedDueToError = null;
try
{
crossImport = EntryImporter.GetOrAddCrossImportOrPackage(origImportFullName, importingPCC, destinationPcc);
}
catch (Exception e)
{
//Error during relink
DebugOutput.StartDebugger("PCC Relinker");
DebugOutput.PrintLn("Exception occured during relink: ");
DebugOutput.PrintLn(ExceptionHandlerDialogWPF.FlattenException(e));
DebugOutput.PrintLn("You may want to consider discarding this sessions' changes as relinking was not able to properly finish.");
linkFailedDueToError = e.Message;
}
if (crossImport != null)
{
crossPCCObjectMappingList.Add(origImport, crossImport); //add to mapping to speed up future relinks
uIndex = crossImport.UIndex;
// Debug.WriteLine($"Relink hit: Dynamic CrossImport for {origvalue} {importingPCC.GetEntry(origvalue).FullPath} -> {uIndex}");
}
else
{
string path = importingPCC.GetEntry(uIndex) != null?importingPCC.GetEntry(uIndex).FullPath : "Entry not found: " + uIndex;
if (linkFailedDueToError != null)
{
Debug.WriteLine($"Relink failed: CrossImport porting failed for {relinkingExport.ObjectName.Instanced} {relinkingExport.UIndex}: {propertyName} ({uIndex}): {importingPCC.GetEntry(origvalue).FullPath}");
return($"Relink failed for {prefix}{propertyName} {uIndex} in export {path}({relinkingExport.UIndex}): {linkFailedDueToError}");
}
if (destinationPcc.GetEntry(uIndex) != null)
{
Debug.WriteLine($"Relink failed: CrossImport porting failed for {relinkingExport.ObjectName.Instanced} {relinkingExport.UIndex}: {propertyName} ({uIndex}): {importingPCC.GetEntry(origvalue).FullPath}");
return($"Relink failed: CrossImport porting failed for {prefix}{propertyName} {uIndex} {destinationPcc.GetEntry(uIndex).FullPath} in export {relinkingExport.FullPath}({relinkingExport.UIndex})");
}
return($"Relink failed: New export does not exist - this is probably a bug in cross import code for {prefix}{propertyName} {uIndex} in export {relinkingExport.FullPath}({relinkingExport.UIndex})");
}
}
}
else
{
//It's an export
//Attempt lookup
ExportEntry sourceExport = importingPCC.GetUExport(uIndex);
string fullPath = sourceExport.FullPath;
int indexValue = sourceExport.indexValue;
IEntry existingEntry = destinationPcc.Exports.FirstOrDefault(x => x.FullPath == fullPath && indexValue == x.indexValue);
existingEntry ??= destinationPcc.Imports.FirstOrDefault(x => x.FullPath == fullPath);
if (existingEntry != null)
{
//Debug.WriteLine($"Relink hit [EXPERIMENTAL]: Existing entry in file was found, linking to it: {uIndex} {sourceExport.InstancedFullPath} -> {existingEntry.InstancedFullPath}");
uIndex = existingEntry.UIndex;
}
else if (importExportDependencies)
{
if (!crossPCCObjectMappingList.TryGetValue(sourceExport.Parent, out IEntry parent))
{
parent = EntryImporter.GetOrAddCrossImportOrPackage(sourceExport.ParentFullPath, importingPCC, destinationPcc, true, crossPCCObjectMappingList);
}
ExportEntry importedExport = EntryImporter.ImportExport(destinationPcc, sourceExport, parent?.UIndex ?? 0, true, crossPCCObjectMappingList);
uIndex = importedExport.UIndex;
}
else
{
string path = importingPCC.GetEntry(uIndex)?.FullPath ?? $"Entry not found: {uIndex}";
Debug.WriteLine($"Relink failed in {relinkingExport.ObjectName.Instanced} {relinkingExport.UIndex}: {propertyName} {uIndex} {path}");
return($"Relink failed: {prefix}{propertyName} {uIndex} in export {relinkingExport.FullPath}({relinkingExport.UIndex})");
}
}
return(null);
}