public static GlobalBinaryOverlay GlobalFactory(
OverlayStream stream,
BinaryOverlayFactoryPackage package,
RecordTypeConverter recordTypeConverter)
{
var majorFrame = package.MetaData.Constants.MajorRecordFrame(stream.RemainingMemory);
var globalChar = GlobalCustomParsing.GetGlobalChar(majorFrame);
switch (globalChar)
{
case GlobalInt.TRIGGER_CHAR:
return(GlobalIntBinaryOverlay.GlobalIntFactory(
stream,
package));
case GlobalShort.TRIGGER_CHAR:
return(GlobalShortBinaryOverlay.GlobalShortFactory(
stream,
package));
case GlobalFloat.TRIGGER_CHAR:
return(GlobalFloatBinaryOverlay.GlobalFloatFactory(
stream,
package));
default:
throw new ArgumentException($"Unknown trigger char: {globalChar}");
}
}
public void UnrelatedStandard()
{
RecordTypeConverter conv = new RecordTypeConverter(
new KeyValuePair <RecordType, RecordType>(RecordTypes.DATA, RecordTypes.MAST));
Assert.Equal(RecordTypes.EDID, RecordTypeConverterExt.ConvertToStandard(conv, RecordTypes.EDID));
}
public void CollidingStandard()
{
RecordTypeConverter conv = new RecordTypeConverter(
new KeyValuePair <RecordType, RecordType>(RecordTypes.DATA, RecordTypes.MAST));
Assert.Equal(RecordType.Null, RecordTypeConverterExt.ConvertToStandard(conv, RecordTypes.DATA));
}
public static Global CreateFromBinary(
MutagenFrame frame,
RecordTypeConverter recordTypeConverter)
{
return(GlobalCustomParsing.Create <Global>(
frame,
getter: (f, triggerChar) =>
{
switch (triggerChar)
{
case GlobalInt.TRIGGER_CHAR:
return GlobalInt.CreateFromBinary(f);
case GlobalShort.TRIGGER_CHAR:
return GlobalShort.CreateFromBinary(f);
case GlobalFloat.TRIGGER_CHAR:
return GlobalFloat.CreateFromBinary(f);
case null:
var ret = GlobalFloat.CreateFromBinary(f);
ret.NoTypeDeclaration = true;
return ret;
default:
throw new ArgumentException($"Unknown trigger char: {triggerChar}");
}
}));
}
public void TypicalCustom()
{
RecordTypeConverter conv = new RecordTypeConverter(
new KeyValuePair <RecordType, RecordType>(RecordTypes.DATA, RecordTypes.MAST));
Assert.Equal(RecordTypes.MAST, RecordTypeConverterExt.ConvertToCustom(conv, RecordTypes.DATA));
}
public override async Task Load(XElement node, bool requireName = true)
{
await base.Load(node, requireName);
if (node.TryGetAttribute <string>("maleMarker", out var maleMarker))
{
MaleMarker = new RecordType(maleMarker);
}
if (node.TryGetAttribute <string>("femaleMarker", out var femaleMarker))
{
FemaleMarker = new RecordType(femaleMarker);
}
if (MaleMarker.HasValue != FemaleMarker.HasValue)
{
throw new ArgumentException("Both submarkers must be set at once.");
}
this.MarkerPerGender = node.GetAttribute <bool>("markerPerGender");
if (MaleMarker.HasValue)
{
this.SubTypeGeneration.NullableProperty.OnNext((true, true));
}
FemaleConversions = RecordTypeConverterModule.GetConverter(node.Element(XName.Get("FemaleTypeOverrides", LoquiGenerator.Namespace)));
MaleConversions = RecordTypeConverterModule.GetConverter(node.Element(XName.Get("MaleTypeOverrides", LoquiGenerator.Namespace)));
}
public static IReadOnlyList <T> FactoryForLoqui <T>(
ReadOnlyMemorySlice <byte> mem,
int amount,
int length,
BinaryOverlayFactoryPackage package,
RecordTypeConverter recordTypeConverter,
PluginBinaryOverlay.ConverterFactory <T> getter)
{
return(new NumberedLoquiList <T>(mem, amount, length, package, recordTypeConverter, getter));
}
public static ADamageType CreateFromBinary(
MutagenFrame frame,
RecordTypeConverter recordTypeConverter)
{
var majorMeta = frame.GetMajorRecordFrame();
if (majorMeta.FormVersion >= 78)
{
return(DamageType.CreateFromBinary(frame, recordTypeConverter));
}
else
{
return(DamageTypeIndexed.CreateFromBinary(frame, recordTypeConverter));
}
}
public NumberedLoquiList(
ReadOnlyMemorySlice <byte> mem,
int amount,
int length,
BinaryOverlayFactoryPackage package,
RecordTypeConverter recordTypeConverter,
PluginBinaryOverlay.ConverterFactory <T> getter)
{
this.Amount = amount;
this.Memory = mem;
this.Length = length;
this.Package = package;
this.Getter = getter;
this.RecordTypeConverter = recordTypeConverter;
}
public static ADamageTypeBinaryOverlay ADamageTypeFactory(
OverlayStream stream,
BinaryOverlayFactoryPackage package,
RecordTypeConverter recordTypeConverter)
{
var majorFrame = package.MetaData.Constants.MajorRecordFrame(stream.RemainingMemory);
if (majorFrame.FormVersion >= 78)
{
return(DamageTypeBinaryOverlay.DamageTypeFactory(stream, package, recordTypeConverter));
}
else
{
return(DamageTypeIndexedBinaryOverlay.DamageTypeIndexedFactory(stream, package, recordTypeConverter));
}
}
public static GenderedItem <TItem?> Parse <TItem>(
MutagenFrame frame,
BinaryMasterParseDelegate <TItem> transl,
RecordTypeConverter femaleRecordConverter,
RecordTypeConverter?maleRecordConverter = null)
where TItem : class
{
if (!transl(frame, out var male, maleRecordConverter))
{
male = null;
}
if (!transl(frame, out var female, femaleRecordConverter))
{
female = null;
}
return(new GenderedItem <TItem?>(male, female));
}
public static TypedParseParams With(this TypedParseParams?param, RecordTypeConverter conv, int?lengthOverride)
{
return(new TypedParseParams(
lengthOverride: lengthOverride,
recordTypeConverter: conv));
}
public static void GenerateConverterMember(FileGeneration fg, ObjectGeneration objGen, RecordTypeConverter recordTypeConverter, string nickName)
{
if (recordTypeConverter == null || recordTypeConverter.FromConversions.Count == 0)
{
return;
}
using (var args = new ArgsWrapper(fg,
$"public static RecordTypeConverter {nickName}Converter = new RecordTypeConverter"))
{
foreach (var conv in recordTypeConverter.FromConversions)
{
args.Add((gen) =>
{
using (var args2 = new FunctionWrapper(gen,
"new KeyValuePair<RecordType, RecordType>"))
{
args2.Add($"new RecordType(\"{conv.Key.Type}\")");
args2.Add($"new RecordType(\"{conv.Value.Type}\")");
}
});
}
}
}
public static TypedWriteParams With(this TypedWriteParams?converter, RecordTypeConverter conv)
{
return(new TypedWriteParams(
recordTypeConverter: conv,
overflowRecordType: converter?.OverflowRecordType));
}
