/// <summary> /// 2.1.0 and greater /// </summary> public static bool HasAssetName(FileGeneration generation) => generation >= FileGeneration.FG_210_261;
/// <summary>
/// 1.2.0 and greater
/// </summary>
public static bool IsReadHash(FileGeneration generation)
{
return(generation >= FileGeneration.FG_120_200);
}
protected virtual void ToString_FillInternal(FileGeneration fg)
{
}
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();
}
}
protected override void ToString_FillInternal(FileGeneration fg)
{
base.ToString_FillInternal(fg);
fg.AppendItem(Data, "Data");
}
protected override void ToString_FillInternal(FileGeneration fg)
{
base.ToString_FillInternal(fg);
fg.AppendItem(VariableIndex, "VariableIndex");
}
protected void ToString_FillInternal(FileGeneration fg)
{
fg.AppendItem(Value, "Value");
fg.AppendItem(Weight, "Weight");
}
protected void ToString_FillInternal(FileGeneration fg)
{
fg.AppendItem(Flags, "Flags");
fg.AppendItem(Priority, "Priority");
}
protected void ToString_FillInternal(FileGeneration fg)
{
fg.AppendItem(Min, "Min");
fg.AppendItem(Max, "Max");
}
protected void ToString_FillInternal(FileGeneration fg)
{
fg.AppendItem(Worldspace, "Worldspace");
fg.AppendItem(Flags, "Flags");
}
protected virtual void ToString_FillInternal(FileGeneration fg)
{
fg.AppendItem(CountOrDistance, "CountOrDistance");
}
public SerializedFileStream(EndianStream stream, FileGeneration generation) :
base(stream.BaseStream, stream.AlignPosition, stream.EndianType)
{
Generation = generation;
}
protected void ToString_FillInternal(FileGeneration fg)
{
fg.AppendItem(TrainedSkill, "TrainedSkill");
fg.AppendItem(MaximumTrainingLevel, "MaximumTrainingLevel");
fg.AppendItem(Unknown, "Unknown");
}
/// <summary> /// 1.2.0 and greater /// </summary> public static bool HasHash(FileGeneration generation) => generation >= FileGeneration.FG_120_200;
public override Task GenerateInRegistration(ObjectGeneration obj, FileGeneration fg)
{
var objData = obj.GetObjectData();
GenerateConverterMember(fg, obj.BaseClass, objData.BaseRecordTypeConverter, "Base");
foreach (var field in obj.IterateFields(expandSets: SetMarkerType.ExpandSets.FalseAndInclude, nonIntegrated: true))
{
LoquiType loquiType = field as LoquiType;
if (loquiType == null)
{
switch (field)
{
case WrapperType wrapper:
loquiType = wrapper.SubTypeGeneration as LoquiType;
if (loquiType != null)
{
break;
}
continue;
default:
continue;
}
}
var fieldData = loquiType.GetFieldData();
GenerateConverterMember(fg, loquiType.TargetObjectGeneration, fieldData.RecordTypeConverter, field.Name);
}
if (objData.GameReleaseConverters != null)
{
foreach (var kv in objData.GameReleaseConverters)
{
GenerateConverterMember(fg, obj, kv.Value, kv.Key.ToString());
}
using (var args = new FunctionWrapper(fg,
$"public static {nameof(RecordTypeConverter)}? Get"))
{
args.Add($"{nameof(GameRelease)} release");
}
using (new BraceWrapper(fg))
{
fg.AppendLine($"return release switch");
using (new BraceWrapper(fg)
{
AppendSemicolon = true
})
{
using (var comma = new CommaWrapper(fg))
{
foreach (var kv in objData.GameReleaseConverters)
{
comma.Add($"{nameof(GameRelease)}.{kv.Key} => {kv.Key}Converter");
}
comma.Add($"_ => default({nameof(RecordTypeConverter)})");
}
}
}
}
if (objData.VersionConverters != null)
{
foreach (var kv in objData.VersionConverters)
{
GenerateConverterMember(fg, obj, kv.Value, $"Version{kv.Key}");
}
using (var args = new FunctionWrapper(fg,
$"public static {nameof(RecordTypeConverter)}? Get"))
{
args.Add($"int? version");
}
using (new BraceWrapper(fg))
{
bool first = true;
fg.AppendLine($"if (version == null) return default({nameof(RecordTypeConverter)});");
foreach (var kv in objData.VersionConverters.OrderBy(kv => kv.Key))
{
fg.AppendLine($"{(first ? null : "else ")}if (version.Value >= {kv.Key})");
using (new BraceWrapper(fg))
{
fg.AppendLine($"return Version{kv.Key}Converter;");
}
first = false;
}
fg.AppendLine($"return default({nameof(RecordTypeConverter)});");
}
}
return(base.GenerateInRegistration(obj, fg));
}
protected void ToString_FillInternal(FileGeneration fg)
{
fg.AppendItem(DefaultLandHeight, "DefaultLandHeight");
fg.AppendItem(DefaultWaterHeight, "DefaultWaterHeight");
}
/// <summary>
/// 5.0.0a1 and greater
/// </summary>
private static bool IsRead5Format(FileGeneration generation)
{
return(generation == FileGeneration.FG_500a1 || generation >= FileGeneration.FG_500aunk1);
}
protected void ToString_FillInternal(FileGeneration fg)
{
fg.AppendItem(ObjectType, "ObjectType");
fg.AppendItem(Object, "Object");
fg.AppendItem(Count, "Count");
}
protected void ToString_FillInternal(FileGeneration fg)
{
fg.AppendItem(RelatedWaterDaytime, "RelatedWaterDaytime");
fg.AppendItem(RelatedWaterNighttime, "RelatedWaterNighttime");
fg.AppendItem(RelatedWaterUnderwater, "RelatedWaterUnderwater");
}
protected void ToString_FillInternal(FileGeneration fg)
{
fg.AppendItem(BenchType, "BenchType");
fg.AppendItem(UsesSkill, "UsesSkill");
}
public override async Task GenerateCopyIn(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor nodeAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor translationMaskAccessor)
{
var dict = typeGen as DictType;
var data = dict.GetFieldData();
var subData = dict.ValueTypeGen.GetFieldData();
if (!this.Module.TryGetTypeGeneration(dict.ValueTypeGen.GetType(), out var subTransl))
{
throw new ArgumentException("Unsupported type generator: " + dict.ValueTypeGen);
}
var isAsync = subTransl.IsAsync(dict.ValueTypeGen, read: true);
var binaryType = GetDictType(dict);
if (data.MarkerType.HasValue)
{
fg.AppendLine("frame.Position += Constants.SUBRECORD_LENGTH + long; // Skip marker");
}
else if (binaryType == DictBinaryType.Trigger)
{
fg.AppendLine("frame.Position += Constants.SUBRECORD_LENGTH;");
}
var term = binaryType == DictBinaryType.EnumMap ? "Dict" : "List";
using (var args = new ArgsWrapper(fg,
$"{Loqui.Generation.Utility.Await(isAsync)}{this.NamespacePrefix}{term}{(isAsync ? "Async" : null)}BinaryTranslation<{dict.ValueTypeGen.TypeName(getter: false)}>.Instance.Parse{(binaryType == DictBinaryType.EnumMap ? $"<{dict.KeyTypeGen.TypeName(false)}>" : null)}",
suffixLine: Loqui.Generation.Utility.ConfigAwait(isAsync)))
{
switch (binaryType)
{
case DictBinaryType.SubTrigger:
args.Add($"reader: {Module.ReaderMemberName}");
args.Add($"triggeringRecord: {subData.TriggeringRecordSetAccessor}");
break;
case DictBinaryType.Trigger:
args.Add($"reader: {Module.ReaderMemberName}.Spawn(long)");
break;
case DictBinaryType.EnumMap:
args.Add($"reader: {Module.ReaderMemberName}");
break;
default:
throw new NotImplementedException();
}
args.Add($"item: {itemAccessor}");
var subGenTypes = subData.GenerationTypes.ToList();
var subGen = this.Module.GetTypeGeneration(dict.ValueTypeGen.GetType());
if (subGenTypes.Count <= 1 &&
subTransl.AllowDirectParse(objGen, typeGen, squashedRepeatedList: false))
{
args.Add($"transl: {subTransl.GetTranslatorInstance(dict.ValueTypeGen, getter: false)}.Parse");
}
else if (subGenTypes.Count > 1)
{
args.Add((gen) =>
{
gen.AppendLine($"transl: (MutagenFrame r, RecordType header{(isAsync ? null : $", out {dict.ValueTypeGen.TypeName(getter: false)} dictSubItem")}) =>");
using (new BraceWrapper(gen))
{
gen.AppendLine("switch (header.Type)");
using (new BraceWrapper(gen))
{
foreach (var item in subGenTypes)
{
foreach (var trigger in item.Key)
{
gen.AppendLine($"case \"{trigger.Type}\":");
}
LoquiType targetLoqui = dict.ValueTypeGen as LoquiType;
LoquiType specificLoqui = item.Value as LoquiType;
using (new DepthWrapper(gen))
{
subGen.GenerateCopyInRet(
fg: gen,
objGen: objGen,
targetGen: dict.ValueTypeGen,
typeGen: item.Value,
readerAccessor: "r",
retAccessor: "return ",
outItemAccessor: new Accessor("dictSubItem"),
translationAccessor: "dictTranslMask",
asyncMode: AsyncMode.Off,
errorMaskAccessor: null,
converterAccessor: null,
inline: true);
}
}
gen.AppendLine("default:");
using (new DepthWrapper(gen))
{
gen.AppendLine("throw new NotImplementedException();");
}
}
}
});
}
else
{
args.Add((gen) =>
{
LoquiType targetLoqui = dict.ValueTypeGen as LoquiType;
subGen.GenerateCopyInRet(
fg: gen,
objGen: objGen,
targetGen: dict.ValueTypeGen,
typeGen: targetLoqui,
readerAccessor: "r",
retAccessor: "transl: ",
outItemAccessor: new Accessor("dictSubItem"),
translationAccessor: "dictTranslMask",
asyncMode: AsyncMode.Off,
errorMaskAccessor: null,
converterAccessor: null,
inline: true);
});
}
}
}
public SerializedFileReader(Stream stream, EndianType endianess, FileGeneration generation) :
base(stream, endianess)
{
Generation = generation;
}
/// <summary>
/// Prints the male and female items to the stream
/// </summary>
/// <param name="fg">Stream to print into</param>
/// <param name="name">Optional name to include</param>
public void ToString(FileGeneration fg, string?name)
{
GenderedItem.ToString(this, fg, name);
}
protected override void ToString_FillInternal(FileGeneration fg)
{
base.ToString_FillInternal(fg);
fg.AppendItem(LevelMult, "LevelMult");
}
/// <summary>
/// 2.1.0 and greater
/// </summary>
public static bool IsReadAssetName(FileGeneration generation)
{
return(generation >= FileGeneration.FG_210_261);
}
protected void ToString_FillInternal(FileGeneration fg)
{
fg.AppendItem(Flags, "Flags");
fg.AppendItem(FragmentIndex, "FragmentIndex");
}
protected override void ToString_FillInternal(FileGeneration fg)
{
base.ToString_FillInternal(fg);
}
protected void ToString_FillInternal(FileGeneration fg)
{
fg.AppendItem(Unknown, "Unknown");
fg.AppendItem(ScriptName, "ScriptName");
fg.AppendItem(FragmentName, "FragmentName");
}
void IPrintable.ToString(FileGeneration fg, string?name) => this.ToString(fg, name);
protected void ToString_FillInternal(FileGeneration fg)
{
fg.AppendItem(Reference, "Reference");
fg.AppendItem(Position, "Position");
}
