public override async Task GenerateWrite(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor writerAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor translationMaskAccessor,
Accessor converterAccessor)
{
BufferType zero = typeGen as BufferType;
using (var args = new ArgsWrapper(fg,
$"{this.Namespace}ByteArrayBinaryTranslation.Instance.Write"))
{
args.Add($"writer: {writerAccessor}");
if (zero.Static)
{
args.Add($"item: {objGen.CommonClassName(LoquiInterfaceType.IGetter, MaskType.Normal)}.{typeGen.Name}");
}
else
{
args.Add($"item: {itemAccessor}");
}
}
}
public override async Task GenerateInClass(ObjectGeneration obj, FileGeneration fg)
{
await base.GenerateInClass(obj, fg);
if (WantsTryCreateFromBinary(obj))
{
using (var args = new FunctionWrapper(fg,
"public static bool TryCreateFromBinary"))
{
foreach (var(API, Public) in this.MainAPI.ReaderAPI.IterateAPI(
obj,
TranslationDirection.Reader,
new APILine(OutItemKey, $"out {obj.ObjectName} item")))
{
if (Public)
{
args.Add(API.Result);
}
}
}
using (new BraceWrapper(fg))
{
fg.AppendLine($"var startPos = {ReaderMemberName}.Position;");
using (var args = new ArgsWrapper(fg,
$"item = CreateFromBinary"))
{
args.Add(this.MainAPI.PassArgs(obj, TranslationDirection.Reader));
}
fg.AppendLine($"return startPos != {ReaderMemberName}.Position;");
}
}
await GenerateBinaryOverlayCreates(obj, fg);
}
private void GenerateCustomBinaryEndCreatePartial(ObjectGeneration obj, FileGeneration fg)
{
var data = obj.GetObjectData();
if (data.CustomBinaryEnd == CustomEnd.Off)
{
return;
}
if (data.CustomBinaryEnd == CustomEnd.Normal)
{
using (var args = new ArgsWrapper(fg,
$"public static partial void CustomBinaryEndImport"))
{
args.Add($"{ReaderClass} {ReaderMemberName}");
args.Add($"{obj.Interface(getter: false, internalInterface: true)} obj");
}
using (var args = new FunctionWrapper(fg,
$"public static void CustomBinaryEndImportPublic"))
{
args.Add($"{ReaderClass} {ReaderMemberName}");
args.Add($"{obj.Interface(getter: false, internalInterface: true)} obj");
}
using (new BraceWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
$"CustomBinaryEndImport"))
{
args.AddPassArg(ReaderMemberName);
args.AddPassArg($"obj");
}
}
}
}
public virtual async Task GenerateWrapperRecordTypeParse(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor locationAccessor,
Accessor packageAccessor,
Accessor converterAccessor)
{
switch (typeGen.GetFieldData().BinaryOverlayFallback)
{
case BinaryGenerationType.Normal:
fg.AppendLine($"_{typeGen.Name}Location = {locationAccessor};");
break;
case BinaryGenerationType.Custom:
using (var args = new ArgsWrapper(fg,
$"{typeGen.Name}CustomParse"))
{
args.AddPassArg($"stream");
args.AddPassArg($"finalPos");
args.AddPassArg($"offset");
}
break;
case BinaryGenerationType.NoGeneration:
default:
return;
}
}
public override void GenerateForCopy(FileGeneration fg, Accessor accessor, Accessor rhs, Accessor copyMaskAccessor, bool protectedMembers, bool deepCopy)
{
fg.AppendLine($"if ({(deepCopy ? this.GetTranslationIfAccessor(copyMaskAccessor) : this.SkipCheck(copyMaskAccessor, deepCopy))})");
using (new BraceWrapper(fg))
{
if (this.HasBeenSet)
{
fg.AppendLine($"{accessor.PropertyOrDirectAccess} = {rhs}.{FormIDTypeString};");
}
else
{
if (deepCopy)
{
fg.AppendLine($"{accessor.PropertyOrDirectAccess} = {rhs}.{FormIDTypeString};");
}
else
{
using (var args = new ArgsWrapper(fg,
$"{accessor.PropertyOrDirectAccess}.SetLink"))
{
args.Add($"value: {rhs}");
}
}
}
}
}
private async Task GenerateForRecord(ObjectGeneration obj, FileGeneration fg)
{
if (!obj.IsTopClass)
{
return;
}
using (var args = new FunctionWrapper(fg,
$"public{obj.FunctionOverride()}async Task WriteToXmlFolder"))
{
args.Add("DirectoryPath dir");
args.Add("string name");
args.Add("XElement node");
args.Add("int counter");
args.Add($"ErrorMaskBuilder? errorMask");
}
using (new BraceWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
"this.WriteToXml"))
{
args.Add("node: node");
args.Add("errorMask: errorMask");
args.Add("translationMask: null");
}
}
}
public override async Task GenerateWrapperFields(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor dataAccessor,
int?passedLength,
string passedLengthAccessor,
DataType data = null)
{
DictType dict = typeGen as DictType;
if (GetDictType(dict) != DictBinaryType.EnumMap)
{
// Special case for Groups
return;
}
if (!this.Module.TryGetTypeGeneration(dict.ValueTypeGen.GetType(), out var subTransl))
{
throw new ArgumentException("Unsupported type generator: " + dict.ValueTypeGen);
}
var posStr = data == null ? passedLengthAccessor : $"_{typeGen.Name}Location";
if (data != null)
{
DataBinaryTranslationGeneration.GenerateWrapperExtraMembers(fg, data, objGen, typeGen, passedLengthAccessor);
}
using (var args = new ArgsWrapper(fg,
$"public IReadOnlyDictionary<{dict.KeyTypeGen.TypeName(getter: true)}, {dict.ValueTypeGen.TypeName(getter: true)}> {typeGen.Name} => DictBinaryTranslation<{dict.ValueTypeGen.TypeName(getter: false)}>.Instance.Parse<{dict.KeyTypeGen.TypeName(false)}>"))
{
args.Add($"new {nameof(MutagenFrame)}(new {nameof(MutagenMemoryReadStream)}({dataAccessor}{(posStr == null ? null : $".Slice({posStr})")}, _package.{nameof(BinaryOverlayFactoryPackage.MetaData)}))");
public override async Task GenerateInCommonMixin(ObjectGeneration obj, FileGeneration fg)
{
await base.GenerateInCommonMixin(obj, fg);
if (!await obj.IsMajorRecord())
{
return;
}
using (var args = new FunctionWrapper(fg,
$"public static {obj.ObjectName} Duplicate{obj.GetGenericTypes(MaskType.Normal, MaskType.NormalGetter)}"))
{
args.Wheres.AddRange(obj.GenericTypeMaskWheres(LoquiInterfaceType.IGetter, MaskType.Normal, MaskType.NormalGetter));
args.Add($"this {obj.Interface(obj.GetGenericTypes(MaskType.NormalGetter), getter: true, internalInterface: true)} item");
args.Add($"{nameof(FormKey)} formKey");
args.Add($"{obj.Mask(MaskType.Translation)}? copyMask = null");
}
using (new BraceWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
$"return {obj.CommonClassInstance("item", LoquiInterfaceType.IGetter, CommonGenerics.Functions, MaskType.NormalGetter)}.Duplicate{obj.GetGenericTypes(MaskType.Normal, MaskType.NormalGetter, MaskType.Translation)}"))
{
args.AddPassArg("item");
args.AddPassArg("formKey");
args.Add("copyMask: copyMask?.GetCrystal()");
}
}
fg.AppendLine();
}
public static void GenerateWritePartialMethods(
FileGeneration fg,
ObjectGeneration obj,
TypeGeneration field,
bool isAsync)
{
using (var args = new FunctionWrapper(fg,
$"public 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");
}
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");
}
using (new BraceWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
$"WriteBinary{field.Name}Custom"))
{
args.Add("writer: writer");
args.Add("item: item");
}
}
fg.AppendLine();
}
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,
$"{this.Namespace}ByteArrayBinaryTranslation.Instance.Write"))
{
args.Add($"writer: {writerAccessor}");
args.Add($"item: {itemAccessor}");
if (this.DoErrorMasks)
{
args.Add($"fieldIndex: (int){typeGen.IndexEnumName}");
args.Add($"errorMask: {errorMaskAccessor}");
}
if (data.RecordType.HasValue)
{
args.Add($"header: recordTypeConverter.ConvertToCustom({objGen.RecordTypeHeaderName(data.RecordType.Value)})");
}
if (data.OverflowRecordType.HasValue)
{
args.Add($"overflowRecord: {objGen.RecordTypeHeaderName(data.OverflowRecordType.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.CustomData[Constants.DataKey] as MutagenFieldData;
using (var args = new ArgsWrapper(fg,
$"{this.NamespacePrefix}FilePathBinaryTranslation.Instance.Write{(typeGen.Nullable ? "Nullable" : null)}"))
{
args.Add($"writer: {writerAccessor}");
args.Add($"item: {itemAccessor}");
if (data.RecordType.HasValue)
{
args.Add($"header: recordTypeConverter.ConvertToCustom({objGen.RecordTypeHeaderName(data.RecordType.Value)})");
}
else
{
args.Add($"length: {data.Length.Value}");
}
}
}
public override void GenerateCopyIn(FileGeneration fg, ObjectGeneration objGen, TypeGeneration typeGen, Accessor nodeAccessor, Accessor itemAccessor, Accessor errorMaskAccessor, Accessor translationMaskAccessor)
{
GenderedType gendered = typeGen as GenderedType;
var gen = this.XmlMod.GetTypeGeneration(gendered.SubTypeGeneration.GetType());
MaskGenerationUtility.WrapErrorFieldIndexPush(
fg,
() =>
{
using (var args = new ArgsWrapper(fg,
$"{itemAccessor} = new {typeGen.TypeName(getter: false)}"))
{
args.Add(subFg =>
{
gen.GenerateCopyIn(subFg, objGen, gendered.SubTypeGeneration, nodeAccessor, Accessor.ConstructorParam($"male"), errorMaskAccessor, translationMaskAccessor: null);
});
args.Add(subFg =>
{
gen.GenerateCopyIn(subFg, objGen, gendered.SubTypeGeneration, nodeAccessor, Accessor.ConstructorParam($"female"), errorMaskAccessor, translationMaskAccessor: null);
});
}
},
errorMaskAccessor,
typeGen.HasIndex ? typeGen.IndexEnumInt : default(Accessor));
}
public override async Task GenerateInCommonMixin(ObjectGeneration obj, FileGeneration fg)
{
if (!await obj.IsMajorRecord())
{
return;
}
if (!obj.IsTopClass)
{
return;
}
using (var args = new FunctionWrapper(fg,
$"public static {nameof(IMajorRecordCommon)} {nameof(IDuplicatable.Duplicate)}"))
{
//ToDo
// Modify to getter interface after copy is refactored
args.Add($"this {obj.ObjectName} item");
args.Add("Func<FormKey> getNextFormKey");
args.Add($"IList<({nameof(IMajorRecordCommon)} Record, FormKey OriginalFormKey)>? duplicatedRecords = null");
}
using (new BraceWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
$"return {obj.CommonClassInstance("item", LoquiInterfaceType.IGetter, CommonGenerics.Class, MaskType.Normal)}.{nameof(IDuplicatable.Duplicate)}"))
{
args.AddPassArg("item");
args.AddPassArg("getNextFormKey");
args.AddPassArg("duplicatedRecords");
}
}
}
public override async Task GenerateCopyIn(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor frameAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor translationMaskAccessor)
{
var loqui = typeGen as LoquiType;
var data = loqui.GetFieldData();
if (data.MarkerType.HasValue &&
!data.RecordType.HasValue)
{
fg.AppendLine($"frame.Position += frame.{nameof(MutagenFrame.MetaData)}.{nameof(ParsingBundle.Constants)}.{nameof(GameConstants.SubConstants)}.{nameof(GameConstants.SubConstants.HeaderLength)} + contentLength; // Skip marker");
}
if (loqui.TargetObjectGeneration != null)
{
if (loqui.SetterInterfaceType == LoquiInterfaceType.IGetter)
{
return;
}
if (loqui.Singleton)
{
using (var args = new ArgsWrapper(fg,
$"{Loqui.Generation.Utility.Await(this.IsAsync(typeGen, read: true))}{itemAccessor}.{this.Module.CopyInFromPrefix}{ModNickname}"))
{
args.Add($"frame: {frameAccessor}");
args.Add($"recordTypeConverter: null");
}
}
else
{
if (NeedsHeaderProcessing(loqui))
{
fg.AppendLine($"frame.Position += frame.{nameof(MutagenFrame.MetaData)}.{nameof(ParsingBundle.Constants)}.{nameof(GameConstants.SubConstants)}.{nameof(GameConstants.SubConstants.HeaderLength)}; // Skip header");
}
using (var args = new ArgsWrapper(fg,
$"{itemAccessor} = {loqui.TargetObjectGeneration.Namespace}.{loqui.TypeNameInternal(getter: false, internalInterface: true)}.{this.Module.CreateFromPrefix}{this.Module.ModuleNickname}"))
{
args.Add($"frame: {frameAccessor}");
if (data?.RecordTypeConverter != null &&
data.RecordTypeConverter.FromConversions.Count > 0)
{
args.Add($"recordTypeConverter: {objGen.RegistrationName}.{typeGen.Name}Converter");
}
else if (await NeedsRecordTypeConverter(loqui))
{
args.AddPassArg($"recordTypeConverter");
}
}
}
}
else
{
throw new NotImplementedException();
}
}
protected override async Task GenerateNewSnippet(ObjectGeneration obj, FileGeneration fg)
{
if (await obj.IsMajorRecord())
{
fg.AppendLine($"var ret = new {obj.Name}();");
}
else
{
if (obj.TryGetCustomRecordTypeTriggers(out var customLogicTriggers))
{
using (var args = new ArgsWrapper(fg,
$"var nextRecord = HeaderTranslation.GetNext{(obj.GetObjectType() == ObjectType.Subrecord ? "Subrecord" : "Record")}Type"))
{
args.Add($"reader: {ReaderMemberName}.Reader");
args.Add("contentLength: out var customLen");
}
fg.AppendLine("nextRecord = recordTypeConverter.ConvertToCustom(nextRecord);");
fg.AppendLine("switch (nextRecord.TypeInt)");
using (new BraceWrapper(fg))
{
foreach (var item in customLogicTriggers)
{
fg.AppendLine($"case {item.TypeInt}: // {item.Type}");
}
using (new DepthWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
"return CustomRecordTypeTrigger"))
{
args.Add($"{ReaderMemberName}: {ReaderMemberName}.SpawnWithLength(customLen + {ReaderMemberName}.{nameof(MutagenFrame.MetaData)}.{nameof(ParsingBundle.Constants)}.{nameof(GameConstants.SubConstants)}.{nameof(GameConstants.SubConstants.HeaderLength)})");
args.Add("recordType: nextRecord");
args.AddPassArg("recordTypeConverter");
}
}
fg.AppendLine("default:");
using (new DepthWrapper(fg))
{
fg.AppendLine("break;");
}
}
}
using (var args = new ArgsWrapper(fg,
$"var ret = new {obj.Name}{obj.GetGenericTypes(MaskType.Normal)}"))
{
if (obj.GetObjectType() == ObjectType.Mod)
{
args.AddPassArg("modKey");
}
if (obj.GetObjectData().GameReleaseOptions != null)
{
args.AddPassArg("release");
}
}
if (obj.GetObjectType() == ObjectType.Mod)
{
fg.AppendLine($"{ReaderMemberName}.MetaData.ModKey = modKey;");
}
}
}
public override void GenerateTypicalMakeCopy(FileGeneration fg, Accessor retAccessor, Accessor rhsAccessor, Accessor copyMaskAccessor, bool deepCopy, bool doTranslationMask)
{
if (this.GetObjectType() != ObjectType.Record)
{
base.GenerateTypicalMakeCopy(fg, retAccessor, rhsAccessor, copyMaskAccessor, deepCopy, doTranslationMask: doTranslationMask);
return;
}
switch (this.RefType)
{
case LoquiRefType.Direct:
using (var args = new ArgsWrapper(fg,
$"{retAccessor}({this.TargetObjectGeneration.ObjectName}){rhsAccessor}.{(deepCopy ? "Deep" : null)}Copy"))
{
if (this.RefType == LoquiRefType.Direct)
{
if (!doTranslationMask)
{
args.Add($"copyMask: default(TranslationCrystal)");
}
else if (deepCopy)
{
args.Add($"copyMask: {copyMaskAccessor}?.GetSubCrystal({this.IndexEnumInt})");
}
else
{
args.Add($"copyMask: {copyMaskAccessor}.Specific");
}
}
args.AddPassArg($"errorMask");
}
break;
case LoquiRefType.Generic:
if (deepCopy)
{
fg.AppendLine($"{retAccessor}(r.DeepCopy() as {_generic})!;");
}
else
{
fg.AppendLine($"{retAccessor}{nameof(LoquiRegistration)}.GetCopyFunc<{_generic}, {_generic}Getter>()({rhsAccessor}, null);");
}
break;
case LoquiRefType.Interface:
if (deepCopy)
{
fg.AppendLine($"{retAccessor}(r.DeepCopy() as {this.TypeNameInternal(getter: false, internalInterface: true)})!;");
}
else
{
fg.AppendLine($"{retAccessor}{nameof(LoquiRegistration)}.GetCopyFunc<{this.TypeName()}, {this.TypeName(getter: true)}>(r.GetType(), typeof({this.TypeName(getter: true)}))({rhsAccessor}, null);");
}
break;
default:
throw new NotImplementedException();
}
}
public override void GenerateWrite(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor writerAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor translationMaskAccessor,
Accessor converterAccessor)
{
var data = typeGen.CustomData[Constants.DataKey] as MutagenFieldData;
if (CustomWrite != null)
{
if (CustomWrite(fg, objGen, typeGen, writerAccessor, itemAccessor))
{
return;
}
}
if (data.HasTrigger || !PreferDirectTranslation)
{
using (var args = new ArgsWrapper(fg,
$"{this.Namespace}{this.Typename(typeGen)}BinaryTranslation.Instance.Write{(typeGen.HasBeenSet ? "Nullable" : null)}"))
{
args.Add($"writer: {writerAccessor}");
args.Add($"item: {ItemWriteAccess(typeGen, itemAccessor)}");
if (this.DoErrorMasks)
{
if (typeGen.HasIndex)
{
args.Add($"fieldIndex: (int){typeGen.IndexEnumName}");
}
args.Add($"errorMask: {errorMaskAccessor}");
}
if (data.RecordType.HasValue &&
data.HandleTrigger)
{
args.Add($"header: recordTypeConverter.ConvertToCustom({objGen.RecordTypeHeaderName(data.RecordType.Value)})");
}
foreach (var writeParam in this.AdditionalWriteParams)
{
var get = writeParam(
objGen: objGen,
typeGen: typeGen);
if (get.Failed)
{
continue;
}
args.Add(get.Value);
}
}
}
else
{
fg.AppendLine($"{writerAccessor.DirectAccess}.Write({itemAccessor.DirectAccess});");
}
}
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 (asyncMode != AsyncMode.Off)
{
throw new NotImplementedException();
}
if (inline)
{
fg.AppendLine($"transl: {this.GetTranslatorInstance(typeGen, getter: false)}.Parse");
}
else
{
if (typeGen.TryGetFieldData(out var data) &&
data.RecordType.HasValue)
{
if (inline)
{
throw new NotImplementedException();
}
fg.AppendLine("r.Position += Constants.SUBRECORD_LENGTH;");
}
using (var args = new ArgsWrapper(fg,
$"{outItemAccessor} = {this.Namespace}{this.Typename(typeGen)}BinaryTranslation.Instance.Parse"))
{
args.Add(nodeAccessor.DirectAccess);
if (this.DoErrorMasks)
{
args.Add($"errorMask: {errorMaskAccessor}");
}
foreach (var writeParam in this.AdditionalCopyInRetParams)
{
var get = writeParam(
objGen: objGen,
typeGen: typeGen);
if (get.Failed)
{
continue;
}
args.Add(get.Value);
}
}
fg.AppendLine("return true;");
}
}
bool ReadPercent(FileGeneration fg, ObjectGeneration objGen, TypeGeneration typeGen, Accessor reader, Accessor item)
{
var percType = typeGen as PercentType;
using (var args = new ArgsWrapper(fg,
$"{item} = {nameof(PercentBinaryTranslation)}.Parse"))
{
args.Add($"reader: {reader}");
args.Add($"integerType: {nameof(FloatIntegerType)}.{percType.IntegerType}");
}
return(true);
}
public override void GenerateForCopy(FileGeneration fg, Accessor accessor, Accessor rhs, Accessor copyMaskAccessor, bool protectedMembers, bool deepCopy)
{
if (!deepCopy)
{
throw new NotImplementedException();
}
if (this.Nullable)
{
fg.AppendLine($"if (!{rhs}.TryGet(out var rhs{this.Name}item))");
using (new BraceWrapper(fg))
{
fg.AppendLine($"{accessor} = null;");
}
fg.AppendLine("else");
rhs = $"rhs{this.Name}item";
}
using (new BraceWrapper(fg, doIt: this.Nullable))
{
using (var args = new ArgsWrapper(fg,
$"{accessor} = new GenderedItem<{this.SubTypeGeneration.TypeName(getter: false, needsCovariance: true)}{this.SubTypeGeneration.NullChar}>"))
{
if (this.isLoquiSingle)
{
LoquiType loqui = this.SubTypeGeneration as LoquiType;
args.Add(subFg =>
{
loqui.GenerateTypicalMakeCopy(
subFg,
retAccessor: $"male: ",
rhsAccessor: $"{rhs}.Male{this.SubTypeGeneration.NullChar}",
copyMaskAccessor: $"{copyMaskAccessor}.Male",
deepCopy: deepCopy,
doTranslationMask: false);
});
args.Add(subFg =>
{
loqui.GenerateTypicalMakeCopy(
subFg,
retAccessor: $"female: ",
rhsAccessor: $"{rhs}.Female{this.SubTypeGeneration.NullChar}",
copyMaskAccessor: $"{copyMaskAccessor}.Female",
deepCopy: deepCopy,
doTranslationMask: false);
});
}
else
{
args.Add($"male: {this.SubTypeGeneration.GetDuplicate($"{rhs}.Male")}");
args.Add($"female: {this.SubTypeGeneration.GetDuplicate($"{rhs}.Female")}");
}
}
}
}
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");
}
}
public async Task GenerateForCustomFlagWrapperFields(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor dataAccessor,
int?currentPosition,
string passedLenAccessor,
DataType dataType = null)
{
var fieldData = typeGen.GetFieldData();
var gen = this.Module.GetTypeGeneration(typeGen.GetType());
string loc;
if (fieldData.HasTrigger)
{
using (var args = new ArgsWrapper(fg,
$"partial void {typeGen.Name}CustomParse"))
{
args.Add($"{nameof(OverlayStream)} stream");
args.Add($"long finalPos");
args.Add($"int offset");
}
if (typeGen.Nullable && !typeGen.CanBeNullable(getter: true))
{
fg.AppendLine($"public bool {typeGen.Name}_IsSet => Get{typeGen.Name}IsSetCustom();");
}
loc = $"_{typeGen.Name}Location.Value";
}
else if (dataType != null)
{
loc = $"_{typeGen.Name}Location";
DataBinaryTranslationGeneration.GenerateWrapperExtraMembers(fg, dataType, objGen, typeGen, passedLenAccessor);
}
else
{
loc = passedLenAccessor;
}
using (var args = new ArgsWrapper(fg,
$"public {typeGen.OverrideStr}{typeGen.TypeName(getter: true)}{(typeGen.IsNullable ? "?" : null)} {typeGen.Name} => Get{typeGen.Name}Custom"))
{
if (!fieldData.HasTrigger && dataType == null)
{
args.Add($"location: {loc ?? "0x0"}");
}
}
if (!fieldData.HasTrigger)
{
currentPosition += fieldData.Length ?? await gen.ExpectedLength(objGen, typeGen);
}
}
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");
}
}
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 == null ? typeGen.GetFieldData().RecordType?.ToString() : typeGen.Name)}CustomParse"))
{
args.Add("stream");
args.Add("offset");
}
}
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 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 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 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 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 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);
}
