public override async Task GenerateWrapperFields(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor dataAccessor,
int?passedLength,
string passedLengthAccessor,
DataType data = null)
{
using (var args = new ArgsWrapper(fg,
$"partial void {(typeGen.Name == null ? typeGen.GetFieldData().RecordType?.ToString() : typeGen.Name)}CustomParse"))
{
args.Add($"{nameof(OverlayStream)} stream");
args.Add($"int offset");
}
}
public bool NeedsFlip(TypeGeneration t)
{
if (!(t is P2Int16Type p2))
{
return(false);
}
if (!p2.CustomData.TryGetValue("Flip", out var flip))
{
return(false);
}
if (!(bool)flip)
{
return(false);
}
return(true);
}
protected override string ItemWriteAccess(TypeGeneration typeGen, Accessor itemAccessor)
{
FormLinkType type = typeGen as FormLinkType;
switch (type.FormIDType)
{
case FormLinkType.FormIDTypeEnum.Normal:
return($"{itemAccessor}.FormKey");
case FormLinkType.FormIDTypeEnum.EDIDChars:
return($"{itemAccessor}.EDID");
default:
throw new NotImplementedException();
}
}
public override async Task GenerateWrite(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor writerAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor translationMaskAccessor,
Accessor converterAccessor)
{
this.GenerateWrite(
fg: fg,
obj: objGen,
field: typeGen,
writerAccessor: writerAccessor);
}
public override string TypeName(TypeGeneration typeGen)
{
FormLinkType type = typeGen as FormLinkType;
switch (type.FormIDType)
{
case FormLinkType.FormIDTypeEnum.Normal:
return(base.TypeName(typeGen));
case FormLinkType.FormIDTypeEnum.EDIDChars:
return("RecordType");
default:
throw new NotImplementedException();
}
}
public override void GenerateForCommonXSD(XElement rootElement, TypeGeneration typeGen)
{
var nodeName = Nullable ? "NullableValueType" : "ValueType";
if (rootElement.Elements().Any((e) => e.Attribute("name")?.Value.Equals(nodeName) ?? false))
{
return;
}
rootElement.Add(
new XElement(XmlTranslationModule.XSDNamespace + "complexType",
new XAttribute("name", nodeName),
new XElement(XmlTranslationModule.XSDNamespace + "attribute",
new XAttribute("name", "value"),
new XAttribute("use", Nullable ? "optional" : "required"))));
}
public override void GenerateCopyInRet(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration targetGen,
TypeGeneration typeGen,
Accessor readerAccessor,
AsyncMode asyncMode,
Accessor retAccessor,
Accessor outItemAccessor,
Accessor errorMaskAccessor,
Accessor translationAccessor,
Accessor converterAccessor,
bool inline)
{
throw new NotImplementedException();
}
public override void GenerateCopyInRet(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration targetGen,
TypeGeneration typeGen,
Accessor nodeAccessor,
AsyncMode asyncMode,
Accessor retAccessor,
Accessor outItemAccessor,
Accessor errorMaskAccessor,
Accessor translationMaskAccessor,
Accessor converterAccessor,
bool inline)
{
if (inline)
{
fg.AppendLine($"transl: {this.GetTranslatorInstance(typeGen, getter: false)}.Parse");
return;
}
if (asyncMode != AsyncMode.Off)
{
throw new NotImplementedException();
}
var stringType = typeGen as StringType;
var data = typeGen.GetFieldData();
using (var args = new ArgsWrapper(fg,
$"{retAccessor}{this.NamespacePrefix}StringBinaryTranslation.Instance.Parse"))
{
args.Add(nodeAccessor.Access);
if (this.DoErrorMasks)
{
args.Add($"errorMask: {errorMaskAccessor}");
}
args.Add($"item: out {outItemAccessor}");
args.Add($"parseWhole: {(data.HasTrigger ? "true" : "false")}");
if (data.Length.HasValue)
{
args.Add($"length: {data.Length.Value}");
}
args.Add($"binaryType: {nameof(StringBinaryType)}.{stringType.BinaryType}");
if (stringType.Translated.HasValue)
{
args.Add($"source: {nameof(StringsSource)}.{stringType.Translated.Value}");
}
}
}
public bool FieldFilter(TypeGeneration field)
{
var data = field.GetFieldData();
if (data.RecordType.HasValue ||
field is NothingType or PrimitiveType or FormLinkType or ContainerType or DictType)
{
return(true);
}
if (field is GenderedType gender)
{
return(FieldFilter(gender.SubTypeGeneration));
}
return(false);
}
public override async Task <int?> ExpectedLength(ObjectGeneration objGen, TypeGeneration typeGen)
{
if (typeGen.GetFieldData().Binary != BinaryGenerationType.Normal)
{
return(await base.ExpectedLength(objGen, typeGen));
}
var floatType = typeGen as Mutagen.Bethesda.Generation.FloatType;
if (floatType.IntegerType.HasValue)
{
return(floatType.IntegerType switch
{
FloatIntegerType.UInt => 4,
FloatIntegerType.UShort => 2,
FloatIntegerType.Byte => 1,
_ => throw new NotImplementedException(),
});
public override string GenerateForTypicalWrapper(
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor dataAccessor,
Accessor packageAccessor)
{
BoolType b = typeGen as BoolType;
if (b.BoolAsMarker == null)
{
return($"{dataAccessor}[0] == 1");
}
else
{
return("true");
}
}
public override async Task GenerateCopyIn(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor readerAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor translationMaskAccessor)
{
GenerateFill(
fg: fg,
objGen: objGen,
field: typeGen,
frameAccessor: readerAccessor,
isAsync: false,
useReturnValue: true);
}
public void GenerateWrite(
FileGeneration fg,
ObjectGeneration obj,
TypeGeneration field,
Accessor writerAccessor)
{
using (var args = new ArgsWrapper(fg,
$"{this.Module.TranslationWriteClass(obj)}.WriteBinary{field.Name}"))
{
args.Add($"writer: {writerAccessor}");
args.Add("item: item");
if (DoErrorMasksStatic)
{
args.Add("errorMask: errorMask");
}
}
}
public override void GenerateForCtor(FileGeneration fg, TypeGeneration field, string typeStr, string valueStr)
{
if (!field.IntegrateField)
{
return;
}
var gendered = field as GenderedType;
if (field.Nullable || gendered.SubTypeGeneration is LoquiType)
{
fg.AppendLine($"this.{field.Name} = new MaskItem<{MaskModule.GenItem}, GenderedItem<{SubMaskString(field, typeStr)}>?>({valueStr}, default);");
}
else
{
fg.AppendLine($"this.{field.Name} = new GenderedItem<{SubMaskString(field, typeStr)}>({valueStr}, {valueStr});");
}
}
public override async Task <int?> ExpectedLength(ObjectGeneration objGen, TypeGeneration typeGen)
{
GenderedType gender = typeGen as GenderedType;
if (!this.Module.TryGetTypeGeneration(gender.SubTypeGeneration.GetType(), out var subTransl))
{
throw new ArgumentException("Unsupported type generator: " + gender.SubTypeGeneration);
}
var expected = await subTransl.ExpectedLength(objGen, gender.SubTypeGeneration);
if (expected == null)
{
return(null);
}
return(expected.Value * 2);
}
public override bool AllowDirectParse(
ObjectGeneration objGen,
TypeGeneration typeGen,
bool squashedRepeatedList)
{
var str = typeGen as Mutagen.Bethesda.Generation.StringType;
if (str.BinaryType != StringBinaryType.NullTerminate)
{
return(false);
}
if (str.Translated.HasValue)
{
return(false);
}
return(!squashedRepeatedList);
}
public override async Task GenerateWrapperRecordTypeParse(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor locationAccessor,
Accessor packageAccessor,
Accessor converterAccessor)
{
using (var args = new ArgsWrapper(fg,
$"{typeGen.Name}SpecialParse"))
{
args.AddPassArg("stream");
args.AddPassArg("offset");
args.AddPassArg("type");
args.AddPassArg("lastParsed");
}
}
public override void GenerateCopyIn(
StructuredStringBuilder sb,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor nodeAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor translationMaskAccessor)
{
var loquiGen = typeGen as LoquiType;
if (loquiGen.Singleton)
{
if (loquiGen.SetterInterfaceType == LoquiInterfaceType.IGetter)
{
return;
}
MaskGenerationUtility.WrapErrorFieldIndexPush(
sb,
() =>
{
using (var args = sb.Call(
$"{itemAccessor.Access}.{XmlMod.CopyInFromPrefix}{XmlMod.ModuleNickname}{loquiGen.GetGenericTypes(getter: false, MaskType.Normal)}"))
{
args.Add($"node: {nodeAccessor}");
args.Add($"translationMask: {translationMaskAccessor}");
args.Add($"errorMask: {errorMaskAccessor}");
}
},
errorMaskAccessor: "errorMask",
indexAccessor: $"{typeGen.IndexEnumInt}");
}
else
{
GenerateCopyInRet_Internal(
sb: sb,
objGen: objGen,
typeGen: typeGen,
nodeAccessor: nodeAccessor,
itemAccessor: itemAccessor,
translationMaskAccessor: translationMaskAccessor,
indexAccessor: typeGen.HasIndex ? $"(int){typeGen.IndexEnumName}" : null,
errorMaskAccessor: errorMaskAccessor);
}
}
public static void GenerateWritePartialMethods(
FileGeneration fg,
ObjectGeneration obj,
TypeGeneration field,
bool isAsync)
{
using (var args = new FunctionWrapper(fg,
$"static partial void WriteBinary{field.Name}Custom{obj.GetGenericTypes(MaskType.Normal)}"))
{
args.Wheres.AddRange(obj.GenerateWhereClauses(LoquiInterfaceType.IGetter, defs: obj.Generics));
args.SemiColon = true;
args.Add($"{nameof(MutagenWriter)} writer");
args.Add($"{obj.Interface(getter: true, internalInterface: true)} item");
if (DoErrorMasksStatic)
{
args.Add($"ErrorMaskBuilder errorMask");
}
}
fg.AppendLine();
using (var args = new FunctionWrapper(fg,
$"public static void WriteBinary{field.Name}{obj.GetGenericTypes(MaskType.Normal)}"))
{
args.Wheres.AddRange(obj.GenerateWhereClauses(LoquiInterfaceType.IGetter, defs: obj.Generics));
args.Add($"{nameof(MutagenWriter)} writer");
args.Add($"{obj.Interface(getter: true, internalInterface: true)} item");
if (DoErrorMasksStatic)
{
args.Add($"ErrorMaskBuilder errorMask");
}
}
using (new BraceWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
$"WriteBinary{field.Name}Custom"))
{
args.Add("writer: writer");
args.Add("item: item");
if (DoErrorMasksStatic)
{
args.Add($"errorMask: errorMask");
}
}
}
fg.AppendLine();
}
public override async Task GenerateCopyIn(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor readerAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor translationMaskAccessor)
{
var data = typeGen.GetFieldData();
using (var args = new ArgsWrapper(fg,
$"SpecialParse_{typeGen.Name}"))
{
args.AddPassArg("item");
args.AddPassArg("frame");
}
}
public override void GenerateCopyIn(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor frameAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor translationMaskAccessor)
{
FormLinkType linkType = typeGen as FormLinkType;
MaskGenerationUtility.WrapErrorFieldIndexPush(fg,
() =>
{
if (itemAccessor.IsAssignment)
{
using (var args = new ArgsWrapper(fg,
$"{itemAccessor} = {(linkType.FormIDType == FormLinkType.FormIDTypeEnum.Normal ? "FormKey" : "RecordType")}XmlTranslation.Instance.Parse"))
{
args.AddPassArg("node");
args.AddPassArg("errorMask");
}
}
else
{
using (var args = new FunctionWrapper(fg,
itemAccessor.Assign($"new {linkType.DirectTypeName(getter: false)}")))
{
args.Add(subFg =>
{
using (var subArgs = new FunctionWrapper(subFg,
$"FormKeyXmlTranslation.Instance.Parse"))
{
subArgs.AddPassArg("node");
subArgs.AddPassArg("errorMask");
}
});
}
}
},
indexAccessor: typeGen.HasIndex?typeGen.IndexEnumInt: null,
errorMaskAccessor: errorMaskAccessor,
doIt: typeGen.HasIndex);
}
public override async Task GenerateCopyIn(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor frameAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor translationMaskAccessor)
{
var data = typeGen.CustomData[Constants.DataKey] as MutagenFieldData;
if (data.HasTrigger)
{
fg.AppendLine($"{frameAccessor}.Position += {frameAccessor}.{nameof(MutagenBinaryReadStream.MetaData)}.{nameof(ParsingBundle.Constants)}.{nameof(GameConstants.SubConstants)}.{nameof(RecordHeaderConstants.HeaderLength)};");
}
string framePass;
if (data.HasTrigger)
{
framePass = $"{frameAccessor}.SpawnWithLength(contentLength)";
}
else if (data.Length.HasValue)
{
framePass = $"{frameAccessor}.SpawnWithLength({data.Length.Value})";
}
else
{
framePass = frameAccessor.ToString();
}
TranslationGeneration.WrapParseCall(
new TranslationWrapParseArgs()
{
FG = fg,
TypeGen = typeGen,
TranslatorLine = $"{this.Namespace}ByteArrayBinaryTranslation.Instance",
MaskAccessor = errorMaskAccessor,
ItemAccessor = itemAccessor,
IndexAccessor = typeGen.IndexEnumInt,
ExtraArgs = $"frame: {framePass}".AsEnumerable(),
SkipErrorMask = !this.DoErrorMasks
});
}
public override void GenerateCopyInRet(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration targetGen,
TypeGeneration typeGen,
Accessor nodeAccessor,
AsyncMode asyncMode,
Accessor retAccessor,
Accessor outItemAccessor,
Accessor errorMaskAccessor,
Accessor translationAccessor,
Accessor converterAccessor,
bool inline)
{
if (inline)
{
fg.AppendLine($"transl: {this.GetTranslatorInstance(typeGen, getter: false)}.Parse");
return;
}
var data = typeGen.CustomData[Constants.DataKey] as MutagenFieldData;
using (var args = new ArgsWrapper(fg,
$"{retAccessor}{Loqui.Generation.Utility.Await(asyncMode)}{this.Namespace}ByteArrayBinaryTranslation.Instance.Parse",
suffixLine: Loqui.Generation.Utility.ConfigAwait(asyncMode)))
{
args.Add(nodeAccessor.Access);
if (this.DoErrorMasks)
{
args.Add($"errorMask: out {errorMaskAccessor}");
}
if (asyncMode == AsyncMode.Off)
{
args.Add($"item: out {outItemAccessor}");
}
if (data.HasTrigger)
{
args.Add($"length: subLength");
}
else
{
args.Add($"length: {data.Length.Value}");
}
}
}
public override async Task GenerateWrite(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor writerAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor translationMaskAccessor,
Accessor converterAccessor)
{
var data = typeGen.GetFieldData();
using (var args = new ArgsWrapper(fg,
$"{objGen.CommonClass(LoquiInterfaceType.ISetter, CommonGenerics.Class)}.SpecialWrite_{typeGen.Name}_Internal"))
{
args.AddPassArg("item");
args.AddPassArg("writer");
}
}
public void GenerateFill(
FileGeneration fg,
TypeGeneration field,
Accessor frameAccessor,
bool isAsync)
{
var data = field.GetFieldData();
using (var args = new ArgsWrapper(fg,
$"{Loqui.Generation.Utility.Await(isAsync)}{this.Module.TranslationCreateClass(field.ObjectGen)}.FillBinary{field.Name}Custom"))
{
args.Add($"frame: {(data.HasTrigger ? $"{frameAccessor}.SpawnWithLength(frame.{nameof(MutagenFrame.MetaData)}.{nameof(ParsingBundle.Constants)}.{nameof(GameConstants.SubConstants)}.{nameof(GameConstants.SubConstants.HeaderLength)} + contentLength)" : frameAccessor)}");
args.Add("item: item");
if (DoErrorMasksStatic)
{
args.Add("errorMask: errorMask");
}
}
}
public override void GenerateForField(FileGeneration fg, TypeGeneration field, string typeStr)
{
if (!field.IntegrateField)
{
return;
}
GenderedType gendered = field as GenderedType;
string maskStr;
if (field.Nullable || gendered.SubTypeGeneration is LoquiType)
{
maskStr = $"MaskItem<{typeStr}, GenderedItem<{SubMaskString(field, typeStr)}>?>?";
}
else
{
maskStr = $"GenderedItem<{SubMaskString(field, typeStr)}>";
}
fg.AppendLine($"public {maskStr} {field.Name};");
}
public override string GenerateForTypicalWrapper(ObjectGeneration objGen, TypeGeneration typeGen, Accessor dataAccessor, Accessor packageAccessor)
{
var eType = typeGen as EnumType;
switch (eType.ByteLength)
{
case 1:
return($"({eType.TypeName(getter: true)}){dataAccessor}[0]");
case 2:
return($"({eType.TypeName(getter: true)})BinaryPrimitives.ReadUInt16LittleEndian({dataAccessor})");
case 4:
return($"({eType.TypeName(getter: true)})BinaryPrimitives.ReadInt32LittleEndian({dataAccessor})");
default:
throw new NotImplementedException();
}
}
bool WritePercent(FileGeneration fg, ObjectGeneration objGen, TypeGeneration typeGen, Accessor writer, Accessor item)
{
var percType = typeGen as PercentType;
var data = percType.GetFieldData();
using (var args = new ArgsWrapper(fg,
$"{nameof(PercentBinaryTranslation)}.Write"))
{
args.Add($"writer: {writer}");
args.Add($"item: {item}");
args.Add($"integerType: {nameof(FloatIntegerType)}.{percType.IntegerType}");
if (data.RecordType.HasValue &&
data.HandleTrigger)
{
args.Add($"header: translationParams.ConvertToCustom({objGen.RecordTypeHeaderName(data.RecordType.Value)})");
}
}
return(true);
}
public override void GenerateWrite(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor writerAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor nameAccessor,
Accessor translationMaskAccessor)
{
StringType str = typeGen as StringType;
if (str.Translated.HasValue)
{
using (var args = new ArgsWrapper(fg,
$"Mutagen.Bethesda.Xml.TranslatedStringXmlTranslation.Instance.Write"))
{
args.Add($"{XmlTranslationModule.XElementLine.GetParameterName(objGen)}: {writerAccessor}");
args.Add($"name: {nameAccessor}");
args.Add($"item: {ItemWriteAccess(typeGen, itemAccessor)}");
if (typeGen.HasIndex)
{
args.Add($"fieldIndex: (int){typeGen.IndexEnumName}");
}
args.Add($"errorMask: {errorMaskAccessor}");
}
}
else
{
using (var args = new ArgsWrapper(fg,
$"{this.TypeName(typeGen)}XmlTranslation.Instance.Write"))
{
args.Add($"{XmlTranslationModule.XElementLine.GetParameterName(objGen)}: {writerAccessor}");
args.Add($"name: {nameAccessor}");
args.Add($"item: {ItemWriteAccess(typeGen, itemAccessor)}");
if (typeGen.HasIndex)
{
args.Add($"fieldIndex: (int){typeGen.IndexEnumName}");
}
args.Add($"errorMask: {errorMaskAccessor}");
}
}
}
public override void GenerateCopyIn(
StructuredStringBuilder sb,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor nodeAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor translationMaskAccessor)
{
GenerateCopyIn_Internal(
sb: sb,
objGen: objGen,
typeGen: typeGen,
nodeAccessor: nodeAccessor,
itemAccessor: itemAccessor,
ret: false,
translationMaskAccessor: translationMaskAccessor,
errorMaskAccessor: errorMaskAccessor);
}
