public override async Task GenerateWrite(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor writerAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor translationMaskAccessor,
Accessor converterAccessor)
{
var eType = typeGen as EnumType;
var data = typeGen.CustomData[Constants.DataKey] as MutagenFieldData;
var nullable = typeGen.Nullable && eType.NullableFallbackInt == null;
using (var args = new ArgsWrapper(fg,
$"{NamespacePrefix}{GetTranslatorInstance(typeGen, getter: true)}.Write{(nullable ? "Nullable" : null)}"))
{
args.Add(writerAccessor.Access);
if (eType.NullableFallbackInt == null)
{
args.Add($"{itemAccessor}");
}
else
{
args.Add($"((int?){itemAccessor}) ?? {eType.NullableFallbackInt}");
}
args.Add($"length: {eType.ByteLength}");
if (this.DoErrorMasks)
{
if (typeGen.HasIndex)
{
args.Add($"fieldIndex: (int){typeGen.IndexEnumName}");
}
args.Add($"errorMask: {errorMaskAccessor}");
}
if (data.RecordType.HasValue)
{
args.Add($"header: translationParams.ConvertToCustom({objGen.RecordTypeHeaderName(data.RecordType.Value)})");
}
}
}
public override async Task GenerateWrite(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor writerAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor translationMaskAccessor,
Accessor converterAccessor)
{
var stringType = typeGen as StringType;
var data = typeGen.CustomData[Constants.DataKey] as MutagenFieldData;
using (var args = new ArgsWrapper(fg,
$"{this.NamespacePrefix}StringBinaryTranslation.Instance.Write{(typeGen.Nullable ? "Nullable" : null)}"))
{
args.Add($"writer: {writerAccessor}");
args.Add($"item: {itemAccessor}");
if (this.DoErrorMasks)
{
if (typeGen.HasIndex)
{
args.Add($"fieldIndex: (int){typeGen.IndexEnumName}");
}
args.Add($"errorMask: {errorMaskAccessor}");
}
if (data.RecordType.HasValue)
{
args.Add($"header: translationParams.ConvertToCustom({objGen.RecordTypeHeaderName(data.RecordType.Value)})");
}
else 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 void GenerateWrite(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor writerAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor translationMaskAccessor,
Accessor converterAccessor)
{
BoolType b = typeGen as BoolType;
if (b.BoolAsMarker == null)
{
base.GenerateWrite(
fg,
objGen,
typeGen,
writerAccessor,
itemAccessor,
errorMaskAccessor,
translationMaskAccessor,
converterAccessor);
}
else
{
var data = typeGen.GetFieldData();
using (var args = new ArgsWrapper(fg,
$"{this.Namespace}BooleanBinaryTranslation.Instance.WriteAsMarker"))
{
args.Add($"writer: {writerAccessor}");
args.Add($"item: {ItemWriteAccess(typeGen, itemAccessor)}");
if (data.RecordType.HasValue &&
data.HandleTrigger)
{
args.Add($"header: recordTypeConverter.ConvertToCustom({objGen.RecordTypeHeaderName(data.RecordType.Value)})");
}
}
}
}
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)
{
throw new NotImplementedException();
}
var data = typeGen.CustomData[Constants.DataKey] as MutagenFieldData;
using (var args = new ArgsWrapper(fg,
$"{retAccessor}{Loqui.Generation.Utility.Await(asyncMode)}{this.NamespacePrefix}FilePathBinaryTranslation.Instance.Parse",
suffixLine: Loqui.Generation.Utility.ConfigAwait(asyncMode)))
{
args.Add(nodeAccessor.Access);
if (asyncMode == AsyncMode.Off)
{
args.Add($"item: out {outItemAccessor}");
}
if (data.RecordType.HasValue)
{
args.Add($"header: recordTypeConverter.Convert({objGen.RecordTypeHeaderName(data.RecordType.Value)})");
}
else
{
args.Add($"length: {data.Length.Value}");
}
}
}
public override async Task GenerateCopyIn(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor readerAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor translationAccessor)
{
GenderedType gender = typeGen as GenderedType;
var data = typeGen.GetFieldData();
if (!this.Module.TryGetTypeGeneration(gender.SubTypeGeneration.GetType(), out var subTransl))
{
throw new ArgumentException("Unsupported type generator: " + gender.SubTypeGeneration);
}
if (data.RecordType.HasValue)
{
fg.AppendLine($"{readerAccessor}.Position += {readerAccessor}.{nameof(MutagenBinaryReadStream.MetaData)}.{nameof(ParsingBundle.Constants)}.{nameof(GameConstants.SubConstants)}.{nameof(RecordHeaderConstants.HeaderLength)};");
}
else if (data.MarkerType.HasValue && !gender.MarkerPerGender)
{
fg.AppendLine($"{readerAccessor}.Position += {readerAccessor}.{nameof(MutagenBinaryReadStream.MetaData)}.{nameof(ParsingBundle.Constants)}.{nameof(GameConstants.SubConstants)}.{nameof(RecordHeaderConstants.HeaderLength)} + contentLength; // Skip marker");
}
bool notNull = gender.ItemNullable && !gender.SubTypeGeneration.IsNullable;
using (var args = new ArgsWrapper(fg,
$"{itemAccessor} = {this.NamespacePrefix}GenderedItemBinaryTranslation.Parse{(gender.MarkerPerGender ? "MarkerPerItem" : null)}<{gender.SubTypeGeneration.TypeName(getter: false, needsCovariance: true)}>"))
{
args.AddPassArg($"frame");
if (gender.MaleMarker.HasValue)
{
args.Add($"maleMarker: {objGen.RecordTypeHeaderName(gender.MaleMarker.Value)}");
args.Add($"femaleMarker: {objGen.RecordTypeHeaderName(gender.FemaleMarker.Value)}");
}
if (data.MarkerType.HasValue && gender.MarkerPerGender)
{
args.Add($"marker: {objGen.RecordTypeHeaderName(data.MarkerType.Value)}");
}
var subData = gender.SubTypeGeneration.GetFieldData();
if (subData.RecordType.HasValue &&
!(gender.SubTypeGeneration is LoquiType))
{
args.Add($"contentMarker: {objGen.RecordTypeHeaderName(subData.RecordType.Value)}");
}
LoquiType loqui = gender.SubTypeGeneration as LoquiType;
if (loqui != null)
{
if (subData?.RecordTypeConverter != null &&
subData.RecordTypeConverter.FromConversions.Count > 0)
{
args.Add($"parseParams: {objGen.RegistrationName}.{typeGen.Name}Converter");
}
}
if (gender.FemaleConversions != null)
{
args.Add($"femaleRecordConverter: {objGen.RegistrationName}.{typeGen.Name}FemaleConverter");
}
if (gender.MaleConversions != null)
{
args.Add($"maleRecordConverter: {objGen.RegistrationName}.{typeGen.Name}MaleConverter");
}
bool needsRecordConv = gender.SubTypeGeneration.NeedsRecordConverter();
if (subTransl.AllowDirectParse(objGen, gender.SubTypeGeneration, false))
{
if (loqui != null)
{
args.Add($"transl: {loqui.ObjectTypeName}{loqui.GenericTypes(getter: false)}.TryCreateFromBinary");
}
else
{
args.Add($"transl: {subTransl.GetTranslatorInstance(gender.SubTypeGeneration, getter: false)}.Parse");
if (gender.ItemNullable)
{
args.Add($"skipMarker: false");
}
}
}
else
{
args.Add(gen =>
{
gen.AppendLine($"transl: (MutagenFrame r, out {gender.SubTypeGeneration.TypeName(getter: false, needsCovariance: true)} genSubItem{(needsRecordConv ? $", {nameof(RecordTypeConverter)}? conv" : null)}) =>");
using (new BraceWrapper(gen))
{
subTransl.GenerateCopyInRet(
fg: gen,
objGen: objGen,
targetGen: gender.SubTypeGeneration,
typeGen: gender.SubTypeGeneration,
readerAccessor: "r",
translationAccessor: null,
retAccessor: "return ",
outItemAccessor: new Accessor("genSubItem"),
asyncMode: AsyncMode.Off,
errorMaskAccessor: "listErrMask",
converterAccessor: "conv",
inline: false);
}
if (gender.ItemNullable)
{
args.Add($"skipMarker: false");
}
});
}
if (notNull)
{
args.Add($"fallback: {gender.SubTypeGeneration.GetDefault(getter: false)}");
}
}
}
public override async Task GenerateWrite(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor writerAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor translationAccessor,
Accessor converterAccessor)
{
GenderedType gendered = typeGen as GenderedType;
var gen = this.Module.GetTypeGeneration(gendered.SubTypeGeneration.GetType());
var data = typeGen.GetFieldData();
if (!this.Module.TryGetTypeGeneration(gendered.SubTypeGeneration.GetType(), out var subTransl))
{
throw new ArgumentException("Unsupported type generator: " + gendered.SubTypeGeneration);
}
var allowDirectWrite = subTransl.AllowDirectWrite(objGen, gendered.SubTypeGeneration);
var loqui = gendered.SubTypeGeneration as LoquiType;
bool needsMasters = gendered.SubTypeGeneration is FormLinkType || (loqui != null && loqui.GetFieldData().HasTrigger);
var typeName = gendered.SubTypeGeneration.TypeName(getter: true, needsCovariance: true);
if (loqui != null)
{
typeName = loqui.TypeNameInternal(getter: true, internalInterface: true);
}
using (var args = new ArgsWrapper(fg,
$"GenderedItemBinaryTranslation.Write{(gendered.MarkerPerGender ? "MarkerPerItem" : null)}"))
{
args.Add($"writer: {writerAccessor}");
args.Add($"item: {itemAccessor}");
if (data.RecordType.HasValue)
{
args.Add($"recordType: {objGen.RecordTypeHeaderName(data.RecordType.Value)}");
}
else if (data.MarkerType.HasValue)
{
args.Add($"markerType: {objGen.RecordTypeHeaderName(data.MarkerType.Value)}");
}
if (gendered.MaleMarker.HasValue)
{
args.Add($"maleMarker: {objGen.RecordTypeHeaderName(gendered.MaleMarker.Value)}");
}
if (gendered.FemaleMarker.HasValue)
{
args.Add($"femaleMarker: {objGen.RecordTypeHeaderName(gendered.FemaleMarker.Value)}");
}
if (gendered.MaleMarker.HasValue &&
loqui != null)
{
args.Add("markerWrap: false");
}
if (gendered.FemaleConversions != null)
{
args.Add($"femaleRecordConverter: {objGen.RegistrationName}.{typeGen.Name}FemaleConverter");
}
if (gendered.MaleConversions != null)
{
args.Add($"maleRecordConverter: {objGen.RegistrationName}.{typeGen.Name}MaleConverter");
}
if (allowDirectWrite)
{
args.Add($"transl: {subTransl.GetTranslatorInstance(gendered.SubTypeGeneration, getter: true)}.Write{(gendered.SubTypeGeneration.Nullable ? "Nullable" : string.Empty)}");
}
else
{
args.Add((gen) =>
{
var listTranslMask = this.MaskModule.GetMaskModule(gendered.SubTypeGeneration.GetType()).GetTranslationMaskTypeStr(gendered.SubTypeGeneration);
gen.AppendLine($"transl: (MutagenWriter subWriter, {typeName}{gendered.SubTypeGeneration.NullChar} subItem{(needsMasters ? $", {nameof(TypedWriteParams)}? conv" : null)}) =>");
using (new BraceWrapper(gen))
{
subTransl.GenerateWrite(
fg: gen,
objGen: objGen,
typeGen: gendered.SubTypeGeneration,
writerAccessor: "subWriter",
translationAccessor: "subTranslMask",
itemAccessor: new Accessor($"subItem"),
errorMaskAccessor: null,
converterAccessor: needsMasters ? "conv" : null);
}
});
}
}
}
public override async Task GenerateWrapperFields(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor dataAccessor,
int?currentPosition,
string passedLengthAccessor,
DataType dataType = null)
{
var data = typeGen.CustomData[Constants.DataKey] as MutagenFieldData;
switch (data.BinaryOverlayFallback)
{
case BinaryGenerationType.Normal:
break;
case BinaryGenerationType.NoGeneration:
return;
case BinaryGenerationType.Custom:
await this.Module.CustomLogic.GenerateForCustomFlagWrapperFields(
fg,
objGen,
typeGen,
dataAccessor,
currentPosition,
passedLengthAccessor,
dataType);
return;
default:
throw new NotImplementedException();
}
if (data.HasTrigger)
{
fg.AppendLine($"private int? _{typeGen.Name}Location;");
}
if (data.RecordType.HasValue)
{
if (dataType != null)
{
throw new ArgumentException();
}
if (data.OverflowRecordType.HasValue)
{
using (var args = new ArgsWrapper(fg,
$"public {typeGen.TypeName(getter: true)}{(typeGen.Nullable ? "?" : null)} {typeGen.Name} => {nameof(UtilityTranslation)}.{nameof(UtilityTranslation.ReadByteArrayWithOverflow)}"))
{
args.Add(dataAccessor.ToString());
args.Add($"_package.{nameof(BinaryOverlayFactoryPackage.MetaData)}.{nameof(ParsingBundle.Constants)}");
args.Add($"_{typeGen.Name}Location");
args.Add(objGen.RecordTypeHeaderName(data.OverflowRecordType.Value));
}
}
else
{
fg.AppendLine($"public {typeGen.TypeName(getter: true)}{(typeGen.Nullable ? "?" : null)} {typeGen.Name} => _{typeGen.Name}Location.HasValue ? {nameof(HeaderTranslation)}.{nameof(HeaderTranslation.ExtractSubrecordMemory)}(_data, _{typeGen.Name}Location.Value, _package.{nameof(BinaryOverlayFactoryPackage.MetaData)}.{nameof(ParsingBundle.Constants)}) : {(typeGen.Nullable ? $"default(ReadOnlyMemorySlice<byte>?)" : "UtilityTranslation.Zeros.Slice(0, 0)")};");
}
}
else
{
if (dataType == null)
{
if (typeGen.Nullable)
{
fg.AppendLine($"public {typeGen.TypeName(getter: true)}{(typeGen.Nullable ? "?" : null)} {typeGen.Name} => {dataAccessor}.Length >= {(currentPosition + (await this.ExpectedLength(objGen, typeGen)).Value)} ? {dataAccessor}.Span.Slice({passedLengthAccessor ?? "0x0"}, {data.Length.Value}).ToArray() : default(ReadOnlyMemorySlice<byte>?);");
}
else if (data.Length.HasValue)
{
fg.AppendLine($"public {typeGen.TypeName(getter: true)}{(typeGen.Nullable ? "?" : null)} {typeGen.Name} => {dataAccessor}.Span.Slice({passedLengthAccessor ?? "0x0"}, 0x{data.Length.Value:X}).ToArray();");
}
else
{
fg.AppendLine($"public {typeGen.TypeName(getter: true)}{(typeGen.Nullable ? "?" : null)} {typeGen.Name} => {dataAccessor}.Span{(passedLengthAccessor == null ? null : $".Slice({passedLengthAccessor})")}.ToArray();");
public override async Task GenerateWrite(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor writerAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor translationMask,
Accessor converterAccessor)
{
var dict = typeGen as DictType;
var subData = dict.ValueTypeGen.GetFieldData();
var data = typeGen.GetFieldData();
if (data.MarkerType.HasValue)
{
fg.AppendLine($"using (HeaderExport.ExportHeader(writer, {objGen.RegistrationName}.{data.MarkerType.Value.Type}_HEADER, ObjectType.Subrecord)) {{ }}");
}
var binaryType = GetDictType(dict);
if (!this.Module.TryGetTypeGeneration(dict.ValueTypeGen.GetType(), out var valTransl))
{
throw new ArgumentException("Unsupported type generator: " + dict.ValueTypeGen);
}
if (dict.Mode == DictMode.KeyedValue ||
binaryType == DictBinaryType.EnumMap)
{
var term = binaryType == DictBinaryType.EnumMap ? "Dict" : "List";
using (var args = new ArgsWrapper(fg,
$"{this.NamespacePrefix}{term}BinaryTranslation<{dict.ValueTypeGen.TypeName(getter: true)}>.Instance.Write"))
{
args.Add($"writer: {writerAccessor}");
args.Add($"items: {itemAccessor}{(binaryType == DictBinaryType.EnumMap ? null : ".Items")}");
if (binaryType == DictBinaryType.Trigger)
{
args.Add($"recordType: {objGen.RecordTypeHeaderName(data.RecordType.Value)}");
}
if (valTransl.AllowDirectWrite(objGen, typeGen))
{
args.Add($"transl: {valTransl.GetTranslatorInstance(dict.ValueTypeGen, getter: true)}.Write");
}
else
{
args.Add((gen) =>
{
gen.AppendLine($"transl: (MutagenWriter r, {dict.ValueTypeGen.TypeName(getter: true)} dictSubItem) =>");
using (new BraceWrapper(gen))
{
LoquiType targetLoqui = dict.ValueTypeGen as LoquiType;
valTransl.GenerateWrite(
fg: gen,
objGen: objGen,
typeGen: targetLoqui,
itemAccessor: new Accessor("dictSubItem"),
writerAccessor: "r",
translationAccessor: "dictTranslMask",
errorMaskAccessor: null,
converterAccessor: null);
}
});
}
}
}
else
{
throw new NotImplementedException();
}
}
public override async Task GenerateWrite(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor writerAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor translationMaskAccessor,
Accessor converterAccessor)
{
var loquiGen = typeGen as LoquiType;
bool isGroup = objGen.GetObjectType() == ObjectType.Mod &&
loquiGen.TargetObjectGeneration.GetObjectData().ObjectType == ObjectType.Group;
if (typeGen.Nullable)
{
fg.AppendLine($"if ({itemAccessor}.TryGet(out var {typeGen.Name}Item))");
itemAccessor = $"{typeGen.Name}Item";
}
else
{
// We want to cache retrievals, in case it's a wrapper being written
fg.AppendLine($"var {typeGen.Name}Item = {itemAccessor};");
itemAccessor = $"{typeGen.Name}Item";
}
using (new BraceWrapper(fg, doIt: typeGen.Nullable))
{
if (isGroup)
{
var dictGroup = loquiGen.TargetObjectGeneration.Name == "Group";
fg.AppendLine($"if ({itemAccessor}.{(dictGroup ? "RecordCache" : "Records")}.Count > 0)");
}
using (new BraceWrapper(fg, doIt: isGroup))
{
var data = loquiGen.GetFieldData();
if (data.MarkerType.HasValue)
{
fg.AppendLine($"using ({nameof(HeaderExport)}.{nameof(HeaderExport.Subrecord)}(writer, {objGen.RecordTypeHeaderName(data.MarkerType.Value)})) {{ }}");
}
var needsHeaderWrite = false;
if (NeedsHeaderProcessing(loquiGen))
{
needsHeaderWrite = true;
fg.AppendLine($"using ({nameof(HeaderExport)}.{nameof(HeaderExport.Subrecord)}(writer, {loquiGen.GetFieldData().TriggeringRecordSetAccessor}))");
}
using (new BraceWrapper(fg, doIt: needsHeaderWrite))
{
string line;
if (loquiGen.TargetObjectGeneration != null)
{
line = $"(({this.Module.TranslationWriteClassName(loquiGen.TargetObjectGeneration)})(({nameof(IBinaryItem)}){itemAccessor}).{this.Module.TranslationWriteItemMember})";
}
else
{
line = $"(({this.Module.TranslationWriteInterface})(({nameof(IBinaryItem)}){itemAccessor}).{this.Module.TranslationWriteItemMember})";
}
using (var args = new ArgsWrapper(fg, $"{line}.Write{loquiGen.GetGenericTypes(true, MaskType.Normal)}"))
{
args.Add($"item: {itemAccessor}");
args.Add($"writer: {writerAccessor}");
if (data?.RecordTypeConverter != null &&
data.RecordTypeConverter.FromConversions.Count > 0)
{
args.Add($"recordTypeConverter: {objGen.RegistrationName}.{(typeGen.Name ?? typeGen.Parent?.Name)}Converter");
}
else if (converterAccessor != null)
{
args.Add($"recordTypeConverter: {converterAccessor}");
}
}
}
}
}
}
public override void GenerateWrite(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor writerAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor translationMaskAccessor,
Accessor converterAccessor)
{
FormLinkType linkType = typeGen as FormLinkType;
var data = typeGen.GetFieldData();
switch (linkType.FormIDType)
{
case FormLinkType.FormIDTypeEnum.Normal:
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)})");
}
}
}
else
{
fg.AppendLine($"{writerAccessor.DirectAccess}.Write({itemAccessor.DirectAccess});");
}
break;
case FormLinkType.FormIDTypeEnum.EDIDChars:
using (var args = new ArgsWrapper(fg,
$"{this.Namespace}RecordTypeBinaryTranslation.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)
{
}
}
break;
default:
break;
}
}
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;
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.Nullable ? "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 if (typeGen.GetFieldData().Length > 1)
{
fg.AppendLine($"{writerAccessor}.Write({itemAccessor}, length: {typeGen.GetFieldData().Length});");
}
else
{
fg.AppendLine($"{writerAccessor}.Write({itemAccessor});");
}
}