public override Task GenerateInClass(ObjectGeneration obj, FileGeneration fg)
{
return(Generate(obj, fg));
}
public override bool AllowDirectParse(
ObjectGeneration objGen,
TypeGeneration typeGen,
bool squashedRepeatedList) => false;
public override async Task PostFieldLoad(ObjectGeneration obj, TypeGeneration field, XElement node)
{
await base.PostFieldLoad(obj, field, node);
field.GetFieldData().CustomFolder = node.TryGetAttribute <bool>("customFolder", out var customFolder) && customFolder;
}
public override async Task <int?> ExpectedLength(ObjectGeneration objGen, TypeGeneration typeGen)
{
return(0);
}
public override bool AllowDirectWrite(
ObjectGeneration objGen,
TypeGeneration typeGen) => false;
public override XElement GenerateForXSD(ObjectGeneration obj, XElement rootElement, XElement choiceElement, TypeGeneration typeGen, string nameOverride)
{
return(null);
}
public override async Task GenerateInCommonMixin(ObjectGeneration obj, FileGeneration fg)
{
if (await MajorRecordModule.HasMajorRecordsInTree(obj, includeBaseClass: false) == Case.No)
{
return;
}
var needsCatch = obj.GetObjectType() == ObjectType.Mod;
string catchLine = needsCatch ? ".Catch(e => throw RecordException.Factory(e, obj.ModKey))" : string.Empty;
string enderSemi = needsCatch ? string.Empty : ";";
fg.AppendLine("[DebuggerStepThrough]");
using (var args = new FunctionWrapper(fg,
$"public static IEnumerable<{nameof(IMajorRecordCommonGetter)}> EnumerateMajorRecords{obj.GetGenericTypes(MaskType.Normal)}"))
{
args.Wheres.AddRange(obj.GenerateWhereClauses(LoquiInterfaceType.IGetter, obj.Generics));
args.Add($"this {obj.Interface(getter: true, internalInterface: true)} obj");
}
using (new BraceWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
$"return {obj.CommonClassInstance("obj", LoquiInterfaceType.IGetter, CommonGenerics.Class)}.EnumerateMajorRecords",
suffixLine: catchLine))
{
args.AddPassArg("obj");
}
}
fg.AppendLine();
fg.AppendLine("[DebuggerStepThrough]");
using (var args = new FunctionWrapper(fg,
$"public static IEnumerable<TMajor> EnumerateMajorRecords{obj.GetGenericTypes(MaskType.Normal, "TMajor")}"))
{
args.Wheres.AddRange(obj.GenerateWhereClauses(LoquiInterfaceType.IGetter, obj.Generics));
args.Wheres.Add($"where TMajor : class, IMajorRecordCommonGetter");
args.Add($"this {obj.Interface(getter: true, internalInterface: true)} obj");
args.Add($"bool throwIfUnknown = true");
}
using (new BraceWrapper(fg))
{
using (var args = new FunctionWrapper(fg,
$"return {obj.CommonClassInstance("obj", LoquiInterfaceType.IGetter, CommonGenerics.Class)}.EnumerateMajorRecords"))
{
args.AddPassArg("obj");
args.Add("type: typeof(TMajor)");
args.AddPassArg("throwIfUnknown");
}
using (new DepthWrapper(fg))
{
fg.AppendLine($".Select(m => (TMajor)m){enderSemi}");
if (needsCatch)
{
fg.AppendLine($"{catchLine};");
}
}
}
fg.AppendLine();
fg.AppendLine("[DebuggerStepThrough]");
using (var args = new FunctionWrapper(fg,
$"public static IEnumerable<{nameof(IMajorRecordCommonGetter)}> EnumerateMajorRecords{obj.GetGenericTypes(MaskType.Normal)}"))
{
args.Add($"this {obj.Interface(getter: true, internalInterface: true)} obj");
args.Add($"Type type");
args.Add($"bool throwIfUnknown = true");
args.Wheres.AddRange(obj.GenerateWhereClauses(LoquiInterfaceType.IGetter, obj.Generics));
}
using (new BraceWrapper(fg))
{
using (var args = new FunctionWrapper(fg,
$"return {obj.CommonClassInstance("obj", LoquiInterfaceType.IGetter, CommonGenerics.Class)}.EnumerateMajorRecords"))
{
args.AddPassArg("obj");
args.AddPassArg("type");
args.AddPassArg("throwIfUnknown");
}
using (new DepthWrapper(fg))
{
fg.AppendLine($".Select(m => ({nameof(IMajorRecordCommonGetter)})m){enderSemi}");
if (needsCatch)
{
fg.AppendLine($"{catchLine};");
}
}
}
fg.AppendLine();
fg.AppendLine("[DebuggerStepThrough]");
using (var args = new FunctionWrapper(fg,
$"public static IEnumerable<{nameof(IMajorRecordCommon)}> EnumerateMajorRecords{obj.GetGenericTypes(MaskType.Normal)}"))
{
args.Wheres.AddRange(obj.GenerateWhereClauses(LoquiInterfaceType.ISetter, obj.Generics));
args.Add($"this {obj.Interface(getter: false, internalInterface: true)} obj");
}
using (new BraceWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
$"return {obj.CommonClassInstance("obj", LoquiInterfaceType.ISetter, CommonGenerics.Class)}.EnumerateMajorRecords",
suffixLine: catchLine))
{
args.AddPassArg("obj");
}
}
fg.AppendLine();
fg.AppendLine("[DebuggerStepThrough]");
using (var args = new FunctionWrapper(fg,
$"public static IEnumerable<TMajor> EnumerateMajorRecords{obj.GetGenericTypes(MaskType.Normal, "TMajor")}"))
{
args.Wheres.AddRange(obj.GenerateWhereClauses(LoquiInterfaceType.ISetter, obj.Generics));
args.Wheres.Add($"where TMajor : class, IMajorRecordCommon");
args.Add($"this {obj.Interface(getter: false, internalInterface: true)} obj");
}
using (new BraceWrapper(fg))
{
using (var args = new FunctionWrapper(fg,
$"return {obj.CommonClassInstance("obj", LoquiInterfaceType.ISetter, CommonGenerics.Class)}.EnumerateMajorRecords"))
{
args.AddPassArg("obj");
args.Add("type: typeof(TMajor)");
args.Add("throwIfUnknown: true");
}
using (new DepthWrapper(fg))
{
fg.AppendLine($".Select(m => (TMajor)m){enderSemi}");
if (needsCatch)
{
fg.AppendLine($"{catchLine};");
}
}
}
fg.AppendLine();
fg.AppendLine("[DebuggerStepThrough]");
using (var args = new FunctionWrapper(fg,
$"public static IEnumerable<{nameof(IMajorRecordCommon)}> EnumerateMajorRecords{obj.GetGenericTypes(MaskType.Normal)}"))
{
args.Add($"this {obj.Interface(getter: false, internalInterface: true)} obj");
args.Add($"Type type");
args.Add($"bool throwIfUnknown = true");
args.Wheres.AddRange(obj.GenerateWhereClauses(LoquiInterfaceType.ISetter, obj.Generics));
}
using (new BraceWrapper(fg))
{
using (var args = new FunctionWrapper(fg,
$"return {obj.CommonClassInstance("obj", LoquiInterfaceType.ISetter, CommonGenerics.Class)}.EnumerateMajorRecords"))
{
args.AddPassArg("obj");
args.AddPassArg("type");
args.AddPassArg("throwIfUnknown");
}
using (new DepthWrapper(fg))
{
fg.AppendLine($".Select(m => ({nameof(IMajorRecordCommon)})m){enderSemi}");
if (needsCatch)
{
fg.AppendLine($"{catchLine};");
}
}
}
fg.AppendLine();
}
public override async Task GenerateInCommonMixin(ObjectGeneration obj, FileGeneration fg)
{
if (obj.GetObjectType() != ObjectType.Mod)
{
return;
}
var needsCatch = obj.GetObjectType() == ObjectType.Mod;
string catchLine = needsCatch ? ".Catch(e => throw RecordException.Factory(e, obj.ModKey))" : string.Empty;
string enderSemi = needsCatch ? string.Empty : ";";
fg.AppendLine("[DebuggerStepThrough]");
using (var args = new FunctionWrapper(fg,
$"public static IEnumerable<IModContext<{obj.GetObjectData().GameCategory.Value.ModInterface(getter: false)}, TSetter, TGetter>> EnumerateMajorRecordContexts{obj.GetGenericTypes(MaskType.Normal, new string[] { "TSetter", "TGetter" })}"))
{
args.Wheres.AddRange(obj.GenerateWhereClauses(LoquiInterfaceType.IGetter, obj.Generics));
args.Wheres.Add($"where TSetter : class, IMajorRecordCommon, TGetter");
args.Wheres.Add($"where TGetter : class, IMajorRecordCommonGetter");
args.Add($"this {obj.Interface(getter: true, internalInterface: true)} obj");
args.Add($"{nameof(ILinkCache)} linkCache");
args.Add($"bool throwIfUnknown = true");
}
using (new BraceWrapper(fg))
{
using (var args = new FunctionWrapper(fg,
$"return {obj.CommonClassInstance("obj", LoquiInterfaceType.IGetter, CommonGenerics.Class)}.EnumerateMajorRecordContexts"))
{
args.AddPassArg("obj");
args.AddPassArg("linkCache");
args.Add("type: typeof(TGetter)");
args.AddPassArg("throwIfUnknown");
}
using (new DepthWrapper(fg))
{
fg.AppendLine($".Select(m => m.AsType<{obj.GetObjectData().GameCategory.Value.ModInterface(getter: false)}, {nameof(IMajorRecordCommon)}, {nameof(IMajorRecordCommonGetter)}, TSetter, TGetter>()){enderSemi}");
if (needsCatch)
{
fg.AppendLine($"{catchLine};");
}
}
}
fg.AppendLine();
fg.AppendLine("[DebuggerStepThrough]");
using (var args = new FunctionWrapper(fg,
$"public static IEnumerable<IModContext<{obj.GetObjectData().GameCategory.Value.ModInterface(getter: false)}, IMajorRecordCommon, IMajorRecordCommonGetter>> EnumerateMajorRecordContexts{obj.GetGenericTypes(MaskType.Normal)}"))
{
args.Add($"this {obj.Interface(getter: true, internalInterface: true)} obj");
args.Add($"{nameof(ILinkCache)} linkCache");
args.Add($"Type type");
args.Add($"bool throwIfUnknown = true");
args.Wheres.AddRange(obj.GenerateWhereClauses(LoquiInterfaceType.IGetter, obj.Generics));
}
using (new BraceWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
$"return {obj.CommonClassInstance("obj", LoquiInterfaceType.IGetter, CommonGenerics.Class)}.EnumerateMajorRecordContexts"))
{
args.AddPassArg("obj");
args.AddPassArg("linkCache");
args.AddPassArg("type");
args.AddPassArg("throwIfUnknown");
}
}
fg.AppendLine();
}
async Task ApplyIterationLines(
ObjectGeneration obj,
TypeGeneration field,
FileGeneration fieldGen,
Accessor accessor,
bool getter,
bool hasTarget = false,
HashSet <ObjectGeneration> blackList = null,
bool includeSelf = true)
{
if (field is GroupType group)
{
if (blackList?.Contains(group.GetGroupTarget()) ?? false)
{
return;
}
if (!hasTarget)
{
fieldGen.AppendLine($"foreach (var item in obj.{field.Name}.EnumerateMajorRecords(type, throwIfUnknown: throwIfUnknown))");
using (new BraceWrapper(fieldGen))
{
using (var args = new ArgsWrapper(fieldGen,
$"yield return new ModContext<{obj.Interface(getter: false)}, IMajorRecordCommon, IMajorRecordCommonGetter>"))
{
args.Add("modKey: obj.ModKey");
args.Add("record: item");
args.Add($"getter: (m, r) => m.{group.Name}.GetOrAddAsOverride(({group.GetGroupTarget().Interface(getter: true, internalInterface: true)})r)");
}
}
}
else
{
fieldGen.AppendLine($"foreach (var groupItem in obj.{field.Name})");
using (new BraceWrapper(fieldGen))
{
fieldGen.AppendLine($"foreach (var item in {group.GetGroupTarget().CommonClass(LoquiInterfaceType.IGetter, CommonGenerics.Class)}.Instance.EnumerateMajorRecordContexts(groupItem, linkCache, type, {(obj.GetObjectType() == ObjectType.Mod ? "obj.ModKey" : "modKey")}, {(obj.GetObjectType() == ObjectType.Mod ? "parent: null" : "curContext")}, throwIfUnknown: throwIfUnknown, getter: (m, r) => m.{field.Name}.GetOrAddAsOverride(linkCache.Resolve<{group.GetGroupTarget().Interface(getter: true, internalInterface: true)}>(r.FormKey))))");
using (new BraceWrapper(fieldGen))
{
fieldGen.AppendLine("yield return item;");
}
}
}
}
else if (field is LoquiType loqui)
{
if (blackList?.Contains(loqui.TargetObjectGeneration) ?? false)
{
return;
}
var fieldAccessor = loqui.Nullable ? $"{obj.ObjectName}{loqui.Name}item" : $"{accessor}.{loqui.Name}";
if (loqui.TargetObjectGeneration.IsListGroup())
{ // List groups
fieldGen.AppendLine($"foreach (var item in obj.{field.Name}.EnumerateMajorRecordContexts(linkCache, type, {(obj.GetObjectType() == ObjectType.Mod ? "obj.ModKey" : "modKey")}, {(obj.GetObjectType() == ObjectType.Mod ? "parent: null" : "curContext")}, throwIfUnknown: throwIfUnknown))");
using (new BraceWrapper(fieldGen))
{
fieldGen.AppendLine("yield return item;");
}
return;
}
var subFg = new FileGeneration();
await LoquiTypeHandler(
subFg,
obj,
fieldAccessor,
loqui,
generic : "TMajor",
checkType : false,
includeSelf : includeSelf,
addGetOrAddArg : (args) =>
{
args.Add(subFg =>
{
subFg.AppendLine($"getter: (m, r) =>");
using (new BraceWrapper(subFg))
{
subFg.AppendLine($"var baseRec = getter(m, linkCache.Resolve<{obj.Interface(getter: true)}>(obj.FormKey));");
subFg.AppendLine($"if (baseRec.{loqui.Name} != null) return baseRec.{loqui.Name};");
subFg.AppendLine($"var copy = ({loqui.TypeName()})(({loqui.Interface(getter: true)})r).DeepCopy(ModContextExt.{loqui.TargetObjectGeneration.Name}CopyMask);");
subFg.AppendLine($"baseRec.{loqui.Name} = copy;");
subFg.AppendLine($"return copy;");
}
});
});
if (subFg.Count == 0)
{
return;
}
if (loqui.Singleton ||
!loqui.Nullable)
{
fieldGen.AppendLines(subFg);
}
else
{
using (new BraceWrapper(fieldGen))
{
fieldGen.AppendLine($"if ({accessor}.{loqui.Name}.TryGet(out var {fieldAccessor}))");
using (new BraceWrapper(fieldGen))
{
fieldGen.AppendLines(subFg);
}
}
}
}
else if (field is ContainerType cont)
{
if (!(cont.SubTypeGeneration is LoquiType contLoqui))
{
return;
}
if (contLoqui.RefType == LoquiType.LoquiRefType.Generic)
{
fieldGen.AppendLine($"foreach (var item in obj.{field.Name})");
using (new BraceWrapper(fieldGen))
{
if (await contLoqui.TargetObjectGeneration.IsMajorRecord())
{
fieldGen.AppendLine($"if (type.IsAssignableFrom(typeof({contLoqui.GenericDef.Name})))");
using (new BraceWrapper(fieldGen))
{
fieldGen.AppendLine($"yield return ({nameof(IMajorRecordCommonGetter)})item;");
}
}
fieldGen.AppendLine($"foreach (var subItem in item.EnumerateMajorRecords(type, throwIfUnknown: throwIfUnknown))");
using (new BraceWrapper(fieldGen))
{
fieldGen.AppendLine($"yield return subItem;");
}
}
}
else if (contLoqui.TargetObjectGeneration?.IsListGroup() ?? false)
{
using (var args = new ArgsWrapper(fieldGen,
$"foreach (var item in {accessor}.{field.Name}.EnumerateMajorRecordContexts",
suffixLine: ")")
{
SemiColon = false
})
{
args.AddPassArg("type");
args.Add($"modKey: {(obj.GetObjectType() == ObjectType.Mod ? "obj.ModKey" : "modKey")}");
args.Add($"parent: {(obj.GetObjectType() == ObjectType.Mod ? "null" : "curContext")}");
args.AddPassArg("linkCache");
args.Add("throwIfUnknown: false");
args.Add("worldspace: obj");
args.AddPassArg("getter");
}
using (new BraceWrapper(fieldGen))
{
fieldGen.AppendLine("yield return item;");
}
}
else
{
var isMajorRecord = contLoqui.TargetObjectGeneration != null && await contLoqui.TargetObjectGeneration.IsMajorRecord();
if (isMajorRecord ||
await MajorRecordModule.HasMajorRecords(contLoqui, includeBaseClass: true) != Case.No)
{
switch (await MajorRecordModule.HasMajorRecords(contLoqui, includeBaseClass: true))
{
case Case.Yes:
fieldGen.AppendLine($"foreach (var subItem in {accessor}.{field.Name}{(field.Nullable ? ".EmptyIfNull()" : null)})");
using (new BraceWrapper(fieldGen))
{
await LoquiTypeHandler(
fieldGen,
obj,
$"subItem",
contLoqui,
generic : "TMajor",
checkType : true,
addGetOrAddArg : (args) =>
{
args.Add(subFg =>
{
subFg.AppendLine($"getter: (m, r) =>");
using (new BraceWrapper(subFg))
{
subFg.AppendLine($"var copy = ({contLoqui.TypeName()})(({contLoqui.Interface(getter: true)})r).DeepCopy();");
subFg.AppendLine($"getter(m, linkCache.Resolve<{obj.Interface(getter: true)}>(obj.FormKey)).{cont.Name}.Add(copy);");
subFg.AppendLine($"return copy;");
}
});
});
}
break;
case Case.Maybe:
throw new NotImplementedException();
case Case.No:
default:
break;
}
}
}
}
else if (field is DictType dict)
{
throw new NotImplementedException();
}
}
private async Task LoquiTypeHandler(
FileGeneration fg,
ObjectGeneration obj,
Accessor loquiAccessor,
LoquiType loquiType,
Action <ArgsWrapper> addGetOrAddArg,
string generic,
bool checkType,
bool includeSelf = true)
{
// ToDo
// Quick hack. Real solution should use reflection to investigate the interface
if (loquiType.RefType == LoquiType.LoquiRefType.Interface)
{
if (checkType)
{
fg.AppendLine($"if (type.IsAssignableFrom({loquiAccessor}.GetType()))");
}
using (new BraceWrapper(fg, doIt: checkType))
{
using (var args = new ArgsWrapper(fg,
$"yield return new ModContext<{obj.GetObjectData().GameCategory.Value.ModInterface(getter: false)}, IMajorRecordCommon, IMajorRecordCommonGetter>"))
{
args.Add($"modKey: {(obj.GetObjectType() == ObjectType.Mod ? "obj.ModKey" : "modKey")}");
args.Add($"record: {loquiAccessor}");
args.Add($"parent: curContext");
addGetOrAddArg(args);
}
}
return;
}
if (includeSelf &&
loquiType.TargetObjectGeneration != null &&
await loquiType.TargetObjectGeneration.IsMajorRecord())
{
if (checkType)
{
fg.AppendLine($"if (type.IsAssignableFrom({loquiAccessor}.GetType()))");
}
using (new BraceWrapper(fg, doIt: checkType))
{
using (var args = new ArgsWrapper(fg,
$"yield return new ModContext<{obj.GetObjectData().GameCategory.Value.ModInterface(getter: false)}, IMajorRecordCommon, IMajorRecordCommonGetter>"))
{
args.Add($"modKey: {(obj.GetObjectType() == ObjectType.Mod ? "obj.ModKey" : "modKey")}");
args.Add($"record: {loquiAccessor}");
args.Add($"parent: curContext");
addGetOrAddArg(args);
}
}
}
if (await MajorRecordModule.HasMajorRecords(loquiType, includeBaseClass: true, includeSelf: false) == Case.No)
{
return;
}
if (obj.IsListGroup())
{
return;
}
if (obj.IsTopLevelGroup())
{
fg.AppendLine($"foreach (var item in {loquiAccessor}.EnumerateMajorRecords({(generic == null ? null : "type, throwIfUnknown: false")}))");
using (new BraceWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
$"yield return new ModContext<{obj.GetObjectData().GameCategory.Value.ModInterface(getter: false)}, IMajorRecordCommon, IMajorRecordCommonGetter>"))
{
args.Add($"modKey: {(obj.GetObjectType() == ObjectType.Mod ? "obj.ModKey" : "modKey")}");
args.Add("record: item");
args.Add($"getOrAddAsOverride: (m, r) => m.{loquiType.Name}.GetOrAddAsOverride(({loquiType.GetGroupTarget().Interface(getter: true, internalInterface: true)})r)");
}
}
}
else
{
using (var args = new ArgsWrapper(fg,
$"foreach (var item in {loquiType.TargetObjectGeneration.CommonClassInstance(loquiAccessor, LoquiInterfaceType.IGetter, CommonGenerics.Class)}.EnumerateMajorRecordContexts",
suffixLine: ")")
{
SemiColon = false
})
{
args.Add($"obj: {loquiAccessor}");
args.AddPassArg("linkCache");
args.AddPassArg("type");
args.Add($"modKey: {(obj.GetObjectType() == ObjectType.Mod ? "obj.ModKey" : "modKey")}");
args.Add($"parent: {(obj.GetObjectType() == ObjectType.Mod ? "null" : "curContext")}");
args.Add("throwIfUnknown: false");
addGetOrAddArg(args);
}
using (new BraceWrapper(fg))
{
fg.AppendLine("yield return item;");
}
}
}
public override async Task GenerateInCommon(ObjectGeneration obj, FileGeneration fg, MaskTypeSet maskTypes)
{
bool getter = maskTypes.Applicable(LoquiInterfaceType.IGetter, CommonGenerics.Class);
if (!getter)
{
return;
}
var accessor = new Accessor("obj");
if (obj.Abstract)
{
return;
}
if (obj.GetObjectType() == ObjectType.Group)
{
return;
}
if (await MajorRecordModule.HasMajorRecordsInTree(obj, includeBaseClass: false) == Case.No)
{
return;
}
var overrideStr = await obj.FunctionOverride(async c => await MajorRecordModule.HasMajorRecords(c, includeBaseClass : false, includeSelf : true) != Case.No);
using (var args = new FunctionWrapper(fg,
$"public{overrideStr}IEnumerable<IModContext<{obj.GetObjectData().GameCategory.Value.ModInterface(getter: false)}, IMajorRecordCommon, IMajorRecordCommonGetter>> EnumerateMajorRecordContexts"))
{
args.Add($"{obj.Interface(getter: getter, internalInterface: true)} obj");
args.Add($"{nameof(ILinkCache)} linkCache");
args.Add($"Type type");
if (obj.GetObjectType() != ObjectType.Mod)
{
args.Add($"{nameof(ModKey)} modKey");
args.Add($"IModContext? parent");
}
args.Add($"bool throwIfUnknown");
if (obj.GetObjectType() == ObjectType.Record)
{
args.Add($"Func<{obj.GetObjectData().GameCategory.Value.ModInterface(getter: false)}, {obj.Interface(getter: true)}, {obj.Interface(getter: false)}> getter");
}
}
using (new BraceWrapper(fg))
{
if (obj.GetObjectType() == ObjectType.Record)
{
using (var args = new ArgsWrapper(fg,
$"var curContext = new ModContext<{obj.GetObjectData().GameCategory.Value.ModInterface(getter: false)}, {obj.Interface(getter: false)}, {obj.Interface(getter: true)}>"))
{
args.Add($"{(obj.GetObjectType() == ObjectType.Mod ? "obj.ModKey" : "modKey")}");
args.Add("record: obj");
args.AddPassArg("getter");
args.AddPassArg("parent");
}
}
var fgCount = fg.Count;
fg.AppendLine("switch (type.Name)");
using (new BraceWrapper(fg))
{
var gameCategory = obj.GetObjectData().GameCategory;
Dictionary <object, FileGeneration> generationDict = new Dictionary <object, FileGeneration>();
foreach (var field in obj.IterateFields())
{
FileGeneration fieldGen;
if (field is LoquiType loqui)
{
if (loqui.TargetObjectGeneration.IsListGroup())
{
continue;
}
var isMajorRecord = loqui.TargetObjectGeneration != null && await loqui.TargetObjectGeneration.IsMajorRecord();
if (!isMajorRecord &&
await MajorRecordModule.HasMajorRecords(loqui, includeBaseClass: true) == Case.No)
{
continue;
}
if (loqui.TargetObjectGeneration.GetObjectType() == ObjectType.Group)
{
fieldGen = generationDict.GetOrAdd(loqui.GetGroupTarget());
}
else
{
fieldGen = generationDict.GetOrAdd(((object)loqui?.TargetObjectGeneration) ?? loqui);
}
}
else if (field is ContainerType cont)
{
if (!(cont.SubTypeGeneration is LoquiType contLoqui))
{
continue;
}
if (contLoqui.RefType == LoquiType.LoquiRefType.Generic)
{
fieldGen = generationDict.GetOrAdd("default:");
}
else
{
fieldGen = generationDict.GetOrAdd(((object)contLoqui?.TargetObjectGeneration) ?? contLoqui);
}
}
else if (field is DictType dict)
{
if (dict.Mode != DictMode.KeyedValue)
{
continue;
}
if (!(dict.ValueTypeGen is LoquiType dictLoqui))
{
continue;
}
if (dictLoqui.RefType == LoquiType.LoquiRefType.Generic)
{
fieldGen = generationDict.GetOrAdd("default:");
}
else
{
fieldGen = generationDict.GetOrAdd(((object)dictLoqui?.TargetObjectGeneration) ?? dictLoqui);
}
}
else
{
continue;
}
await ApplyIterationLines(obj, field, fieldGen, accessor, getter);
}
bool doAdditionlDeepLogic = obj.Name != "ListGroup";
if (doAdditionlDeepLogic)
{
var deepRecordMapping = await MajorRecordModule.FindDeepRecords(obj);
foreach (var deepRec in deepRecordMapping)
{
FileGeneration deepFg = generationDict.GetOrAdd(deepRec.Key);
foreach (var field in deepRec.Value)
{
await ApplyIterationLines(obj, field, deepFg, accessor, getter, hasTarget : true, includeSelf : false);
}
}
HashSet <string> blackList = new HashSet <string>();
foreach (var kv in generationDict)
{
switch (kv.Key)
{
case LoquiType loqui:
if (loqui.RefType == LoquiType.LoquiRefType.Generic)
{
// Handled in default case
continue;
}
else
{
fg.AppendLine($"case \"{loqui.Interface(getter: true)}\":");
fg.AppendLine($"case \"{loqui.Interface(getter: false)}\":");
if (loqui.HasInternalGetInterface)
{
fg.AppendLine($"case \"{loqui.Interface(getter: true, internalInterface: true)}\":");
}
if (loqui.HasInternalSetInterface)
{
fg.AppendLine($"case \"{loqui.Interface(getter: false, internalInterface: true)}\":");
}
if (loqui.RefType == LoquiType.LoquiRefType.Interface)
{
blackList.Add(loqui.SetterInterface);
}
}
break;
case ObjectGeneration targetObj:
fg.AppendLine($"case \"{targetObj.ObjectName}\":");
fg.AppendLine($"case \"{targetObj.Interface(getter: true)}\":");
fg.AppendLine($"case \"{targetObj.Interface(getter: false)}\":");
if (targetObj.HasInternalGetInterface)
{
fg.AppendLine($"case \"{targetObj.Interface(getter: true, internalInterface: true)}\":");
}
if (targetObj.HasInternalSetInterface)
{
fg.AppendLine($"case \"{targetObj.Interface(getter: false, internalInterface: true)}\":");
}
break;
case string str:
if (str != "default:")
{
throw new NotImplementedException();
}
continue;
default:
throw new NotImplementedException();
}
using (new DepthWrapper(fg))
{
fg.AppendLines(kv.Value);
fg.AppendLine("yield break;");
}
}
// Generate for major record marker interfaces
if (LinkInterfaceModule.ObjectMappings.TryGetValue(obj.ProtoGen.Protocol, out var interfs))
{
foreach (var interf in interfs)
{
if (blackList.Contains(interf.Key))
{
continue;
}
FileGeneration subFg = new FileGeneration();
HashSet <ObjectGeneration> passedObjects = new HashSet <ObjectGeneration>();
HashSet <TypeGeneration> deepObjects = new HashSet <TypeGeneration>();
foreach (var subObj in interf.Value)
{
var grup = obj.Fields
.WhereCastable <TypeGeneration, GroupType>()
.Where(g => g.GetGroupTarget() == subObj)
.FirstOrDefault();
if (grup != null)
{
subFg.AppendLine($"foreach (var item in EnumerateMajorRecordContexts({accessor}, linkCache, typeof({grup.GetGroupTarget().Interface(getter: true)}), throwIfUnknown: throwIfUnknown))");
using (new BraceWrapper(subFg))
{
subFg.AppendLine("yield return item;");
}
passedObjects.Add(grup.GetGroupTarget());
}
else if (deepRecordMapping.TryGetValue(subObj, out var deepRec))
{
foreach (var field in deepRec)
{
deepObjects.Add(field);
}
}
}
foreach (var deepObj in deepObjects)
{
await ApplyIterationLines(obj, deepObj, subFg, accessor, getter, blackList : passedObjects, hasTarget : true, includeSelf : false);
}
if (!subFg.Empty)
{
fg.AppendLine($"case \"{interf.Key}\":");
fg.AppendLine($"case \"{interf.Key}Getter\":");
using (new BraceWrapper(fg))
{
fg.AppendLines(subFg);
fg.AppendLine("yield break;");
}
}
}
}
}
fg.AppendLine("default:");
using (new DepthWrapper(fg))
{
if (generationDict.TryGetValue("default:", out var gen))
{
fg.AppendLines(gen);
fg.AppendLine("yield break;");
}
else
{
fg.AppendLine("if (throwIfUnknown)");
using (new BraceWrapper(fg))
{
fg.AppendLine("throw new ArgumentException($\"Unknown major record type: {type}\");");
}
fg.AppendLine($"else");
using (new BraceWrapper(fg))
{
fg.AppendLine("yield break;");
}
}
}
}
}
fg.AppendLine();
}
async Task ApplyRemovalLines(
TypeGeneration field,
FileGeneration fieldGen,
Accessor accessor,
bool removeSelf,
ObjectGeneration obj = null,
HashSet <ObjectGeneration> blackList = null)
{
if (field is GroupType group)
{
if (blackList?.Contains(group.GetGroupTarget()) ?? false)
{
return;
}
using (var args = new ArgsWrapper(fieldGen,
$"obj.{field.Name}.Remove"))
{
args.AddPassArg("type");
args.AddPassArg("keys");
}
}
else if (field is LoquiType loqui)
{
if (blackList?.Contains(loqui.TargetObjectGeneration) ?? false)
{
return;
}
var fieldAccessor = loqui.Nullable ? $"{obj?.ObjectName}{loqui.Name}item" : $"{accessor}.{loqui.Name}";
if (loqui.TargetObjectGeneration.IsListGroup())
{ // List groups
using (var args = new ArgsWrapper(fieldGen,
$"obj.{field.Name}.Remove"))
{
args.AddPassArg("type");
args.AddPassArg("keys");
}
return;
}
var subFg = new FileGeneration();
subFg.AppendLine($"{fieldAccessor}.Remove(keys, type, throwIfUnknown);");
if (loqui.Singleton ||
!loqui.Nullable)
{
fieldGen.AppendLines(subFg);
}
else
{
using (new BraceWrapper(fieldGen))
{
fieldGen.AppendLine($"if ({accessor}.{loqui.Name} is {{}} {fieldAccessor})");
using (new BraceWrapper(fieldGen))
{
fieldGen.AppendLines(subFg);
}
}
}
}
else if (field is ContainerType cont)
{
if (!(cont.SubTypeGeneration is LoquiType contLoqui))
{
return;
}
if (contLoqui.RefType == LoquiType.LoquiRefType.Generic)
{
fieldGen.AppendLine($"foreach (var item in obj.{field.Name})");
using (new BraceWrapper(fieldGen))
{
fieldGen.AppendLine($"item.Remove(keys, type, throwIfUnknown: false);");
}
fieldGen.AppendLine($"obj.{field.Name}.RemoveWhere(i => i.{contLoqui.TargetObjectGeneration.Fields.FirstOrDefault(f => f is ContainerType).Name}.Count == 0);");
}
else
{
var isMajorRecord = contLoqui.TargetObjectGeneration != null && await contLoqui.TargetObjectGeneration.IsMajorRecord();
if (isMajorRecord ||
await MajorRecordModule.HasMajorRecords(contLoqui, includeBaseClass: true) != Case.No)
{
if (removeSelf)
{
fieldGen.AppendLine($"obj.{field.Name}.RemoveWhere(i => keys.Contains(i.FormKey));");
}
switch (await MajorRecordModule.HasMajorRecords(contLoqui, includeBaseClass: true, includeSelf: false))
{
case Case.Yes:
case Case.Maybe:
fieldGen.AppendLine($"foreach (var subItem in {accessor}.{field.Name}{(field.Nullable ? ".EmptyIfNull()" : null)})");
using (new BraceWrapper(fieldGen))
{
fieldGen.AppendLine("subItem.Remove(keys, type, throwIfUnknown: false);");
}
break;
case Case.No:
default:
break;
}
}
}
if (contLoqui.TargetObjectGeneration != null &&
contLoqui.TargetObjectGeneration.IsListGroup() &&
(await contLoqui.TargetObjectGeneration.GetGroupLoquiType()).TargetObjectGeneration == obj)
{
fieldGen.AppendLine($"{accessor}.{field.Name}.RemoveWhere(i => i.{contLoqui.TargetObjectGeneration.Fields.FirstOrDefault(f => f is ContainerType).Name}.Count == 0);");
}
}
else if (field is DictType dict)
{
if (dict.Mode != DictMode.KeyedValue)
{
return;
}
if (!(dict.ValueTypeGen is LoquiType dictLoqui))
{
return;
}
if (dictLoqui.RefType == LoquiType.LoquiRefType.Generic)
{
fieldGen.AppendLine($"if (type.IsAssignableFrom(typeof({dictLoqui.GenericDef.Name})))");
using (new BraceWrapper(fieldGen))
{
fieldGen.AppendLine($"obj.RecordCache.Remove(keys);");
}
fieldGen.AppendLine($"foreach (var item in obj.{field.Name}.Items)");
using (new BraceWrapper(fieldGen))
{
fieldGen.AppendLine($"item.Remove(keys, type, throwIfUnknown: false);");
}
}
else
{
var isMajorRecord = dictLoqui.TargetObjectGeneration != null && await dictLoqui.TargetObjectGeneration.IsMajorRecord();
if (isMajorRecord ||
await MajorRecordModule.HasMajorRecords(dictLoqui, includeBaseClass: true) != Case.No)
{
switch (await MajorRecordModule.HasMajorRecords(dictLoqui, includeBaseClass: true))
{
case Case.Yes:
fieldGen.AppendLine($"foreach (var subItem in {accessor}.{field.Name}.Items)");
using (new BraceWrapper(fieldGen))
{
throw new NotImplementedException();
}
break;
case Case.Maybe:
fieldGen.AppendLine($"foreach (var subItem in {accessor}.{field.Name}.Items.WhereCastable<{dictLoqui.TypeName(getter: false)}, {nameof(IMajorRecordEnumerable)}>())");
using (new BraceWrapper(fieldGen))
{
throw new NotImplementedException();
}
break;
case Case.No:
default:
break;
}
}
}
}
}
public override async Task GenerateInCommonMixin(ObjectGeneration obj, FileGeneration fg)
{
if (await MajorRecordModule.HasMajorRecordsInTree(obj, includeBaseClass: false) == Case.No)
{
return;
}
fg.AppendLine("[DebuggerStepThrough]");
using (var args = new FunctionWrapper(fg,
$"public static void Remove{obj.GetGenericTypes(MaskType.Normal)}"))
{
args.Wheres.AddRange(obj.GenerateWhereClauses(LoquiInterfaceType.ISetter, obj.Generics));
args.Add($"this {obj.Interface(getter: false, internalInterface: true)} obj");
args.Add($"{nameof(FormKey)} key");
}
using (new BraceWrapper(fg))
{
fg.AppendLine($"var keys = new HashSet<{nameof(FormKey)}>();");
fg.AppendLine("keys.Add(key);");
using (var args = new ArgsWrapper(fg,
$"{obj.CommonClassInstance("obj", LoquiInterfaceType.ISetter, CommonGenerics.Class)}.Remove"))
{
args.AddPassArg("obj");
args.AddPassArg("keys");
}
}
fg.AppendLine();
if (await MajorRecordModule.HasMajorRecordsInTree(obj, includeBaseClass: false) == Case.No)
{
return;
}
fg.AppendLine("[DebuggerStepThrough]");
using (var args = new FunctionWrapper(fg,
$"public static void Remove{obj.GetGenericTypes(MaskType.Normal)}"))
{
args.Wheres.AddRange(obj.GenerateWhereClauses(LoquiInterfaceType.ISetter, obj.Generics));
args.Add($"this {obj.Interface(getter: false, internalInterface: true)} obj");
args.Add($"IEnumerable<{nameof(FormKey)}> keys");
}
using (new BraceWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
$"{obj.CommonClassInstance("obj", LoquiInterfaceType.ISetter, CommonGenerics.Class)}.Remove"))
{
args.AddPassArg("obj");
args.Add("keys: keys.ToHashSet()");
}
}
fg.AppendLine();
if (await MajorRecordModule.HasMajorRecordsInTree(obj, includeBaseClass: false) == Case.No)
{
return;
}
fg.AppendLine("[DebuggerStepThrough]");
using (var args = new FunctionWrapper(fg,
$"public static void Remove{obj.GetGenericTypes(MaskType.Normal)}"))
{
args.Wheres.AddRange(obj.GenerateWhereClauses(LoquiInterfaceType.ISetter, obj.Generics));
args.Add($"this {obj.Interface(getter: false, internalInterface: true)} obj");
args.Add($"HashSet<{nameof(FormKey)}> keys");
}
using (new BraceWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
$"{obj.CommonClassInstance("obj", LoquiInterfaceType.ISetter, CommonGenerics.Class)}.Remove"))
{
args.AddPassArg("obj");
args.AddPassArg("keys");
}
}
fg.AppendLine();
fg.AppendLine("[DebuggerStepThrough]");
using (var args = new FunctionWrapper(fg,
$"public static void Remove{obj.GetGenericTypes(MaskType.Normal)}"))
{
args.Wheres.AddRange(obj.GenerateWhereClauses(LoquiInterfaceType.ISetter, obj.Generics));
args.Add($"this {obj.Interface(getter: false, internalInterface: true)} obj");
args.Add($"{nameof(FormKey)} key");
args.Add($"{nameof(Type)} type");
args.Add($"bool throwIfUnknown = true");
}
using (new BraceWrapper(fg))
{
fg.AppendLine($"var keys = new HashSet<{nameof(FormKey)}>();");
fg.AppendLine("keys.Add(key);");
using (var args = new ArgsWrapper(fg,
$"{obj.CommonClassInstance("obj", LoquiInterfaceType.ISetter, CommonGenerics.Class)}.Remove"))
{
args.AddPassArg("obj");
args.AddPassArg("keys");
args.AddPassArg("type");
args.AddPassArg("throwIfUnknown");
}
}
fg.AppendLine();
if (await MajorRecordModule.HasMajorRecordsInTree(obj, includeBaseClass: false) == Case.No)
{
return;
}
fg.AppendLine("[DebuggerStepThrough]");
using (var args = new FunctionWrapper(fg,
$"public static void Remove{obj.GetGenericTypes(MaskType.Normal)}"))
{
args.Wheres.AddRange(obj.GenerateWhereClauses(LoquiInterfaceType.ISetter, obj.Generics));
args.Add($"this {obj.Interface(getter: false, internalInterface: true)} obj");
args.Add($"IEnumerable<{nameof(FormKey)}> keys");
args.Add($"{nameof(Type)} type");
args.Add($"bool throwIfUnknown = true");
}
using (new BraceWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
$"{obj.CommonClassInstance("obj", LoquiInterfaceType.ISetter, CommonGenerics.Class)}.Remove"))
{
args.AddPassArg("obj");
args.Add("keys: keys.ToHashSet()");
args.AddPassArg("type");
args.AddPassArg("throwIfUnknown");
}
}
fg.AppendLine();
if (await MajorRecordModule.HasMajorRecordsInTree(obj, includeBaseClass: false) == Case.No)
{
return;
}
fg.AppendLine("[DebuggerStepThrough]");
using (var args = new FunctionWrapper(fg,
$"public static void Remove{obj.GetGenericTypes(MaskType.Normal)}"))
{
args.Wheres.AddRange(obj.GenerateWhereClauses(LoquiInterfaceType.ISetter, obj.Generics));
args.Add($"this {obj.Interface(getter: false, internalInterface: true)} obj");
args.Add($"HashSet<{nameof(FormKey)}> keys");
args.Add($"{nameof(Type)} type");
args.Add($"bool throwIfUnknown = true");
}
using (new BraceWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
$"{obj.CommonClassInstance("obj", LoquiInterfaceType.ISetter, CommonGenerics.Class)}.Remove"))
{
args.AddPassArg("obj");
args.AddPassArg("keys");
args.AddPassArg("type");
args.AddPassArg("throwIfUnknown");
}
}
fg.AppendLine();
fg.AppendLine("[DebuggerStepThrough]");
using (var args = new FunctionWrapper(fg,
$"public static void Remove{obj.GetGenericTypes(MaskType.Normal, "TMajor")}"))
{
args.Wheres.AddRange(obj.GenerateWhereClauses(LoquiInterfaceType.ISetter, obj.Generics));
args.Add($"this {obj.Interface(getter: false, internalInterface: true)} obj");
args.Add($"TMajor record");
args.Add($"bool throwIfUnknown = true");
args.Wheres.Add($"where TMajor : {nameof(IMajorRecordGetter)}");
}
using (new BraceWrapper(fg))
{
fg.AppendLine($"var keys = new HashSet<{nameof(FormKey)}>();");
fg.AppendLine("keys.Add(record.FormKey);");
using (var args = new ArgsWrapper(fg,
$"{obj.CommonClassInstance("obj", LoquiInterfaceType.ISetter, CommonGenerics.Class)}.Remove"))
{
args.AddPassArg("obj");
args.AddPassArg("keys");
args.Add("type: typeof(TMajor)");
args.AddPassArg("throwIfUnknown");
}
}
fg.AppendLine();
if (await MajorRecordModule.HasMajorRecordsInTree(obj, includeBaseClass: false) == Case.No)
{
return;
}
fg.AppendLine("[DebuggerStepThrough]");
using (var args = new FunctionWrapper(fg,
$"public static void Remove{obj.GetGenericTypes(MaskType.Normal, "TMajor")}"))
{
args.Wheres.AddRange(obj.GenerateWhereClauses(LoquiInterfaceType.ISetter, obj.Generics));
args.Add($"this {obj.Interface(getter: false, internalInterface: true)} obj");
args.Add($"IEnumerable<TMajor> records");
args.Add($"bool throwIfUnknown = true");
args.Wheres.Add($"where TMajor : {nameof(IMajorRecordGetter)}");
}
using (new BraceWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
$"{obj.CommonClassInstance("obj", LoquiInterfaceType.ISetter, CommonGenerics.Class)}.Remove"))
{
args.AddPassArg("obj");
args.Add("keys: records.Select(m => m.FormKey).ToHashSet()");
args.Add("type: typeof(TMajor)");
args.AddPassArg("throwIfUnknown");
}
}
fg.AppendLine();
fg.AppendLine("[DebuggerStepThrough]");
using (var args = new FunctionWrapper(fg,
$"public static void Remove{obj.GetGenericTypes(MaskType.Normal, "TMajor")}"))
{
args.Wheres.AddRange(obj.GenerateWhereClauses(LoquiInterfaceType.ISetter, obj.Generics));
args.Add($"this {obj.Interface(getter: false, internalInterface: true)} obj");
args.Add($"{nameof(FormKey)} key");
args.Add($"bool throwIfUnknown = true");
args.Wheres.Add($"where TMajor : {nameof(IMajorRecordGetter)}");
}
using (new BraceWrapper(fg))
{
fg.AppendLine($"var keys = new HashSet<{nameof(FormKey)}>();");
fg.AppendLine("keys.Add(key);");
using (var args = new ArgsWrapper(fg,
$"{obj.CommonClassInstance("obj", LoquiInterfaceType.ISetter, CommonGenerics.Class)}.Remove"))
{
args.AddPassArg("obj");
args.AddPassArg("keys");
args.Add("type: typeof(TMajor)");
args.AddPassArg("throwIfUnknown");
}
}
fg.AppendLine();
if (await MajorRecordModule.HasMajorRecordsInTree(obj, includeBaseClass: false) == Case.No)
{
return;
}
fg.AppendLine("[DebuggerStepThrough]");
using (var args = new FunctionWrapper(fg,
$"public static void Remove{obj.GetGenericTypes(MaskType.Normal, "TMajor")}"))
{
args.Wheres.AddRange(obj.GenerateWhereClauses(LoquiInterfaceType.ISetter, obj.Generics));
args.Add($"this {obj.Interface(getter: false, internalInterface: true)} obj");
args.Add($"IEnumerable<{nameof(FormKey)}> keys");
args.Add($"bool throwIfUnknown = true");
args.Wheres.Add($"where TMajor : {nameof(IMajorRecordGetter)}");
}
using (new BraceWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
$"{obj.CommonClassInstance("obj", LoquiInterfaceType.ISetter, CommonGenerics.Class)}.Remove"))
{
args.AddPassArg("obj");
args.Add("keys: keys.ToHashSet()");
args.Add("type: typeof(TMajor)");
args.AddPassArg("throwIfUnknown");
}
}
fg.AppendLine();
if (await MajorRecordModule.HasMajorRecordsInTree(obj, includeBaseClass: false) == Case.No)
{
return;
}
fg.AppendLine("[DebuggerStepThrough]");
using (var args = new FunctionWrapper(fg,
$"public static void Remove{obj.GetGenericTypes(MaskType.Normal, "TMajor")}"))
{
args.Wheres.AddRange(obj.GenerateWhereClauses(LoquiInterfaceType.ISetter, obj.Generics));
args.Add($"this {obj.Interface(getter: false, internalInterface: true)} obj");
args.Add($"HashSet<{nameof(FormKey)}> keys");
args.Add($"bool throwIfUnknown = true");
args.Wheres.Add($"where TMajor : {nameof(IMajorRecordGetter)}");
}
using (new BraceWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
$"{obj.CommonClassInstance("obj", LoquiInterfaceType.ISetter, CommonGenerics.Class)}.Remove"))
{
args.AddPassArg("obj");
args.AddPassArg("keys");
args.Add("type: typeof(TMajor)");
args.AddPassArg("throwIfUnknown");
}
}
fg.AppendLine();
}
public override async Task GenerateInCommon(ObjectGeneration obj, FileGeneration fg, MaskTypeSet maskTypes)
{
if (!maskTypes.Applicable(LoquiInterfaceType.ISetter, CommonGenerics.Class))
{
return;
}
var accessor = new Accessor("obj");
if (await MajorRecordModule.HasMajorRecordsInTree(obj, includeBaseClass: false) == Case.No)
{
return;
}
var overrideStr = await obj.FunctionOverride(async c => await MajorRecordModule.HasMajorRecords(c, includeBaseClass : false, includeSelf : true) != Case.No);
using (var args = new FunctionWrapper(fg,
$"public{overrideStr}void Remove"))
{
args.Add($"{obj.Interface(getter: false, internalInterface: true)} obj");
args.Add($"HashSet<{nameof(FormKey)}> keys");
}
using (new BraceWrapper(fg))
{
var fgCount = fg.Count;
foreach (var baseClass in obj.BaseClassTrail())
{
if (await MajorRecordModule.HasMajorRecords(baseClass, includeBaseClass: true, includeSelf: true) != Case.No)
{
fg.AppendLine($"base.Remove(obj, keys);");
break;
}
}
foreach (var field in obj.IterateFields())
{
switch (field)
{
case LoquiType _:
case ContainerType _:
case DictType _:
break;
default:
continue;
}
FileGeneration fieldFg = new FileGeneration();
if (field is LoquiType loqui)
{
var fieldAccessor = $"{accessor}.{loqui.Name}";
if (await MajorRecordModule.HasMajorRecords(loqui.TargetObjectGeneration, includeBaseClass: true, includeSelf: false) != Case.No)
{
fg.AppendLine($"{fieldAccessor}{loqui.NullChar}.Remove(keys);");
}
var isMajorRecord = loqui.TargetObjectGeneration != null && await loqui.TargetObjectGeneration.IsMajorRecord();
if (isMajorRecord)
{
fg.AppendLine($"if ({(loqui.Nullable ? $"{fieldAccessor} != null && " : string.Empty)}keys.Contains({fieldAccessor}.FormKey))");
using (new BraceWrapper(fg))
{
fg.AppendLine($"{fieldAccessor} = null;");
}
}
}
else if (field is ContainerType cont)
{
if (!(cont.SubTypeGeneration is LoquiType contLoqui))
{
continue;
}
var isMajorRecord = await contLoqui.IsMajorRecord();
if (isMajorRecord)
{
fg.AppendLine($"{accessor}.{field.Name}.Remove(keys);");
}
if (await MajorRecordModule.HasMajorRecords(contLoqui, includeBaseClass: true, includeSelf: false) != Case.No)
{
fg.AppendLine($"{accessor}.{field.Name}.ForEach(i => i.Remove(keys));");
}
if (contLoqui.TargetObjectGeneration?.IsListGroup() ?? false)
{
fg.AppendLine($"{accessor}.{field.Name}.RemoveWhere(i => i.{contLoqui.TargetObjectGeneration.Fields.FirstOrDefault(f => f is ContainerType).Name}.Count == 0);");
}
}
else if (field is DictType dict)
{
if (dict.Mode != DictMode.KeyedValue)
{
continue;
}
if (!(dict.ValueTypeGen is LoquiType dictLoqui))
{
continue;
}
var isMajorRecord = dictLoqui.TargetObjectGeneration != null && await dictLoqui.TargetObjectGeneration.IsMajorRecord();
if (isMajorRecord ||
await MajorRecordModule.HasMajorRecords(dictLoqui, includeBaseClass: true) != Case.No)
{
switch (await MajorRecordModule.HasMajorRecords(dictLoqui, includeBaseClass: true))
{
case Case.Yes:
case Case.Maybe:
fg.AppendLine($"{accessor}.{field.Name}.Remove(keys);");
break;
case Case.No:
default:
break;
}
}
}
if (fieldFg.Count > 0)
{
if (field.Nullable)
{
fg.AppendLine($"if ({field.NullableAccessor(getter: true, Accessor.FromType(field, accessor.ToString()))})");
}
using (new BraceWrapper(fg, doIt: field.Nullable))
{
fg.AppendLines(fieldFg);
}
}
}
}
fg.AppendLine();
// Generate base overrides
foreach (var baseClass in obj.BaseClassTrail())
{
if (await MajorRecordModule.HasMajorRecords(baseClass, includeBaseClass: true, includeSelf: true) != Case.No)
{
using (var args = new FunctionWrapper(fg,
$"public override void Remove"))
{
args.Add($"{baseClass.Interface(getter: false)} obj");
args.Add($"HashSet<{nameof(FormKey)}> keys");
}
using (new BraceWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
"Remove"))
{
args.Add($"({obj.Interface(getter: false)})obj");
args.AddPassArg("keys");
}
}
fg.AppendLine();
}
}
using (var args = new FunctionWrapper(fg,
$"public{overrideStr}void Remove"))
{
args.Add($"{obj.Interface(getter: false, internalInterface: true)} obj");
args.Add($"HashSet<{nameof(FormKey)}> keys");
args.Add($"Type type");
args.Add($"bool throwIfUnknown");
}
using (new BraceWrapper(fg))
{
var fgCount = fg.Count;
foreach (var baseClass in obj.BaseClassTrail())
{
if (await MajorRecordModule.HasMajorRecords(baseClass, includeBaseClass: true, includeSelf: true) != Case.No)
{
fg.AppendLine("base.Remove(obj, type, keys);");
break;
}
}
fg.AppendLine("switch (type.Name)");
using (new BraceWrapper(fg))
{
var gameCategory = obj.GetObjectData().GameCategory;
fg.AppendLine($"case \"{nameof(IMajorRecord)}\":");
fg.AppendLine($"case \"{nameof(MajorRecord)}\":");
if (gameCategory != null)
{
fg.AppendLine($"case \"I{gameCategory}MajorRecord\":");
fg.AppendLine($"case \"{gameCategory}MajorRecord\":");
}
fg.AppendLine($"case \"{nameof(IMajorRecordGetter)}\":");
if (gameCategory != null)
{
fg.AppendLine($"case \"I{gameCategory}MajorRecordGetter\":");
}
using (new DepthWrapper(fg))
{
fg.AppendLine($"if (!{obj.RegistrationName}.SetterType.IsAssignableFrom(obj.GetType())) return;");
fg.AppendLine("this.Remove(obj, keys);");
fg.AppendLine("break;");
}
Dictionary <object, FileGeneration> generationDict = new Dictionary <object, FileGeneration>();
foreach (var field in obj.IterateFields())
{
LoquiType targetLoqui;
FileGeneration fieldGen;
if (field is LoquiType loqui)
{
if (loqui.TargetObjectGeneration.IsListGroup())
{
continue;
}
var isMajorRecord = loqui.TargetObjectGeneration != null && await loqui.TargetObjectGeneration.IsMajorRecord();
if (!isMajorRecord &&
await MajorRecordModule.HasMajorRecords(loqui, includeBaseClass: true) == Case.No)
{
continue;
}
if (loqui.TargetObjectGeneration.GetObjectType() == ObjectType.Group)
{
fieldGen = generationDict.GetOrAdd(loqui.GetGroupTarget());
}
else
{
fieldGen = generationDict.GetOrAdd(((object)loqui?.TargetObjectGeneration) ?? loqui);
}
targetLoqui = loqui;
}
else if (field is ContainerType cont)
{
if (!(cont.SubTypeGeneration is LoquiType contLoqui))
{
continue;
}
if (contLoqui.RefType == LoquiType.LoquiRefType.Generic)
{
fieldGen = generationDict.GetOrAdd("default:");
}
else
{
fieldGen = generationDict.GetOrAdd(((object)contLoqui?.TargetObjectGeneration) ?? contLoqui);
}
targetLoqui = contLoqui;
}
else if (field is DictType dict)
{
if (dict.Mode != DictMode.KeyedValue)
{
continue;
}
if (!(dict.ValueTypeGen is LoquiType dictLoqui))
{
continue;
}
if (dictLoqui.RefType == LoquiType.LoquiRefType.Generic)
{
fieldGen = generationDict.GetOrAdd("default:");
}
else
{
fieldGen = generationDict.GetOrAdd(((object)dictLoqui?.TargetObjectGeneration) ?? dictLoqui);
}
targetLoqui = dictLoqui;
}
else
{
continue;
}
bool applicable = false;
switch (targetLoqui.RefType)
{
case LoquiType.LoquiRefType.Direct:
applicable = await targetLoqui.TargetObjectGeneration.IsMajorRecord();
break;
case LoquiType.LoquiRefType.Interface:
applicable = true;
break;
case LoquiType.LoquiRefType.Generic:
default:
break;
}
await ApplyRemovalLines(field, fieldGen, accessor, removeSelf : applicable);
}
bool doAdditionlDeepLogic = !obj.Name.EndsWith("ListGroup");
if (doAdditionlDeepLogic)
{
LinkInterfaceModule.ObjectMappings.TryGetValue(obj.ProtoGen.Protocol, out var interfs);
var deepRecordMapping = await MajorRecordModule.FindDeepRecords(obj);
foreach (var deepRec in deepRecordMapping)
{
FileGeneration deepFg = generationDict.GetOrAdd(deepRec.Key);
foreach (var field in deepRec.Value)
{
var remSelf = false;
switch (field)
{
case ContainerType cont:
if (cont.SubTypeGeneration is LoquiType loqui)
{
switch (loqui.RefType)
{
case LoquiType.LoquiRefType.Direct:
remSelf = loqui.TargetObjectGeneration == deepRec.Key;
break;
case LoquiType.LoquiRefType.Interface:
if (interfs.TryGetValue(loqui.SetterInterface, out var objs))
{
remSelf = objs.Contains(deepRec.Key);
}
break;
case LoquiType.LoquiRefType.Generic:
default:
break;
}
}
break;
default:
break;
}
remSelf &= await deepRec.Key.IsMajorRecord();
await ApplyRemovalLines(field, deepFg, accessor, obj : deepRec.Key, removeSelf : remSelf);
}
}
// Generate for major record marker interfaces
foreach (var interf in interfs.EmptyIfNull())
{
FileGeneration subFg = new FileGeneration();
HashSet <ObjectGeneration> passedObjects = new HashSet <ObjectGeneration>();
HashSet <TypeGeneration> deepObjects = new HashSet <TypeGeneration>();
foreach (var subObj in interf.Value)
{
var grup = obj.Fields
.WhereCastable <TypeGeneration, GroupType>()
.Where(g => g.GetGroupTarget() == subObj)
.FirstOrDefault();
if (grup != null)
{
subFg.AppendLine($"Remove({accessor}, keys, typeof({grup.GetGroupTarget().Interface(getter: true)}), throwIfUnknown: throwIfUnknown);");
passedObjects.Add(grup.GetGroupTarget());
}
else if (deepRecordMapping.TryGetValue(subObj, out var deepRec))
{
foreach (var field in deepRec)
{
deepObjects.Add(field);
}
}
}
foreach (var deepObj in deepObjects)
{
bool remSelf = false;
switch (deepObj)
{
case ContainerType cont:
if (cont.SubTypeGeneration is LoquiType loqui)
{
remSelf = loqui.RefType == LoquiType.LoquiRefType.Interface && loqui.Interface(getter: false) == interf.Key;
}
break;
default:
break;
}
await ApplyRemovalLines(deepObj, subFg, accessor, blackList : passedObjects, removeSelf : remSelf);
}
if (!subFg.Empty)
{
var genFg = generationDict.GetOrAdd(new InterfInstr()
{
Interf = interf.Key
});
genFg.AppendLines(subFg);
}
}
foreach (var kv in generationDict)
{
switch (kv.Key)
{
case LoquiType loqui:
if (loqui.RefType == LoquiType.LoquiRefType.Direct)
{
fg.AppendLine($"case \"{loqui.Interface(getter: true)}\":");
fg.AppendLine($"case \"{loqui.Interface(getter: false)}\":");
if (loqui.HasInternalGetInterface)
{
fg.AppendLine($"case \"{loqui.Interface(getter: true, internalInterface: true)}\":");
}
if (loqui.HasInternalSetInterface)
{
fg.AppendLine($"case \"{loqui.Interface(getter: false, internalInterface: true)}\":");
}
}
else
{
continue;
}
break;
case ObjectGeneration targetObj:
fg.AppendLine($"case \"{targetObj.ObjectName}\":");
fg.AppendLine($"case \"{targetObj.Interface(getter: true)}\":");
fg.AppendLine($"case \"{targetObj.Interface(getter: false)}\":");
if (targetObj.HasInternalGetInterface)
{
fg.AppendLine($"case \"{targetObj.Interface(getter: true, internalInterface: true)}\":");
}
if (targetObj.HasInternalSetInterface)
{
fg.AppendLine($"case \"{targetObj.Interface(getter: false, internalInterface: true)}\":");
}
break;
case InterfInstr interf:
fg.AppendLine($"case \"{interf.Interf}\":");
fg.AppendLine($"case \"{interf.Interf}Getter\":");
break;
case string str:
if (str != "default:")
{
throw new NotImplementedException();
}
continue;
default:
throw new NotImplementedException();
}
using (new DepthWrapper(fg))
{
fg.AppendLines(kv.Value);
fg.AppendLine("break;");
}
}
}
fg.AppendLine("default:");
using (new DepthWrapper(fg))
{
if (generationDict.TryGetValue("default:", out var gen))
{
fg.AppendLines(gen);
fg.AppendLine("break;");
}
else
{
fg.AppendLine("if (throwIfUnknown)");
using (new BraceWrapper(fg))
{
fg.AppendLine("throw new ArgumentException($\"Unknown major record type: {type}\");");
}
fg.AppendLine($"else");
using (new BraceWrapper(fg))
{
fg.AppendLine("break;");
}
}
}
}
}
fg.AppendLine();
// Generate base overrides
foreach (var baseClass in obj.BaseClassTrail())
{
if (await MajorRecordModule.HasMajorRecords(baseClass, includeBaseClass: true, includeSelf: true) != Case.No)
{
using (var args = new FunctionWrapper(fg,
$"public override void Remove"))
{
args.Add($"{baseClass.Interface(getter: false)} obj");
args.Add($"HashSet<{nameof(FormKey)}> keys");
args.Add($"Type type");
args.Add($"bool throwIfUnknown");
}
using (new BraceWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
"Remove"))
{
args.Add($"({obj.Interface(getter: false)})obj");
args.AddPassArg("keys");
args.AddPassArg("type");
args.AddPassArg("throwIfUnknown");
}
}
fg.AppendLine();
}
}
}
public override async Task FinalizeGeneration(ProtocolGeneration proto)
{
await base.FinalizeGeneration(proto);
if (proto.Protocol.Namespace == "Bethesda")
{
return;
}
bool all = proto.Protocol.Namespace == "All";
FileGeneration fg = new FileGeneration();
ObjectGeneration.AddAutogenerationComment(fg);
fg.AppendLine("using Loqui;");
fg.AppendLine();
using (new NamespaceWrapper(fg, proto.DefaultNamespace))
{
using (var comment = new CommentWrapper(fg))
{
comment.Summary.AppendLine("A static class to house initialization warmup logic");
}
using (var c = new ClassWrapper(fg, $"Warmup{proto.Protocol.Namespace}"))
{
c.Static = true;
c.Partial = true;
}
using (new BraceWrapper(fg))
{
using (var comment = new CommentWrapper(fg))
{
comment.Summary.AppendLine("Will initialize internals in a more efficient way that avoids reflection.");
comment.Summary.AppendLine("Not required to call, but can be used to warm up ahead of time.");
if (!all)
{
comment.Summary.AppendLine("<br/><br/>NOTE: Calling this warmup which is for a single game, will require you warm up");
comment.Summary.AppendLine("other games in the same fashion. Use WarmupAll if you want all games to be warmed.");
}
}
using (var args = new FunctionWrapper(fg,
"public static void Init"))
{
}
using (new BraceWrapper(fg))
{
if (all)
{
using (var args = new ArgsWrapper(fg,
$"Loqui.Initialization.SpinUp"))
{
args.Add($"new ProtocolDefinition_Bethesda()");
}
foreach (var otherProto in proto.Gen.Protocols.Values
.Where(p => p.DefaultNamespace.Contains("Mutagen.Bethesda"))
.Where(p => p.DefaultNamespace.Length > "Mutagen.Bethesda".Length)
.Where(p => !object.ReferenceEquals(p, proto)))
{
fg.AppendLine($"{otherProto.DefaultNamespace}.Warmup{otherProto.Protocol.Namespace}.Init();");
}
}
else
{
using (var args = new ArgsWrapper(fg,
$"Loqui.Initialization.SpinUp"))
{
args.Add($"new ProtocolDefinition_Bethesda()");
args.Add($"new ProtocolDefinition_{proto.Protocol.Namespace}()");
}
fg.AppendLine($"Mutagen.Bethesda.Core.LinkInterfaceMapping.AutomaticRegistration = false;");
using (var args = new ArgsWrapper(fg,
$"Mutagen.Bethesda.Core.LinkInterfaceMapping.Register"))
{
args.Add($"new {proto.DefaultNamespace}.Internals.LinkInterfaceMapping()");
}
fg.AppendLine("InitCustom();");
}
}
fg.AppendLine("static partial void InitCustom();");
}
}
var path = Path.Combine(proto.DefFileLocation.FullName, $"../Warmup{proto.Protocol.Namespace}{Loqui.Generation.Constants.AutogeneratedMarkerString}.cs");
fg.Generate(path);
proto.GeneratedFiles.Add(path, ProjItemType.Compile);
}
public override async Task <int?> ExpectedLength(ObjectGeneration objGen, TypeGeneration typeGen)
{
BufferType buf = typeGen as BufferType;
return(buf.Length);
}
public MutagenObjData(ObjectGeneration objGen)
{
this.ObjGen = objGen;
}
public override async Task GenerateWrapperFields(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor dataAccessor,
int?currentPosition,
string passedLengthAccessor,
DataType dataType)
{
LoquiType loqui = typeGen as LoquiType;
var data = typeGen.GetFieldData();
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();
}
string DataAccessor(Accessor accessor, string positionStr, string lenStr)
{
if (objGen.GetObjectType() == ObjectType.Mod)
{
return($"{nameof(BinaryOverlay)}.{nameof(BinaryOverlay.LockExtractMemory)}({accessor}, {positionStr}, {lenStr})");
}
else
{
return($"{accessor}.Slice({positionStr})");
}
}
string recConverter = $"default({nameof(RecordTypeConverter)})";
if (loqui.GetFieldData()?.RecordTypeConverter != null &&
loqui.GetFieldData().RecordTypeConverter.FromConversions.Count > 0)
{
recConverter = $"{objGen.RegistrationName}.{loqui.Name}Converter";
}
var isRequiredRecord = !loqui.Nullable && data.HasTrigger;
if (dataType == null)
{
if (loqui.GetFieldData()?.HasTrigger ?? false)
{
if (loqui.TargetObjectGeneration.IsTypelessStruct())
{
if (loqui.Singleton ||
isRequiredRecord)
{
fg.AppendLine($"private {loqui.Interface(getter: true, internalInterface: true)}? _{typeGen.Name};");
}
else if (loqui.Nullable)
{
fg.AppendLine($"public {loqui.Interface(getter: true, internalInterface: true)}? {typeGen.Name} {{ get; private set; }}");
}
}
else
{
var severalSubTypes = data.GenerationTypes
.Select(i => i.Value)
.WhereCastable <TypeGeneration, LoquiType>()
.Where(loqui => !loqui?.TargetObjectGeneration?.Abstract ?? true)
.CountGreaterThan(1);
if (severalSubTypes)
{
fg.AppendLine($"private {nameof(RecordType)} _{typeGen.Name}Type;");
}
fg.AppendLine($"private {GetLocationObjectString(objGen)}? _{typeGen.Name}Location;");
using (new LineWrapper(fg))
{
if (loqui.IsNullable)
{
fg.Append($"public ");
}
else
{
fg.Append($"private ");
}
fg.Append($"{loqui.Interface(getter: true, internalInterface: true)}{(typeGen.CanBeNullable(getter: true) ? "?" : null)} ");
if (!loqui.IsNullable ||
isRequiredRecord)
{
fg.Append("_");
}
fg.Append($"{typeGen.Name}");
if (!severalSubTypes)
{
fg.Append($" => _{typeGen.Name}Location.HasValue ? ");
fg.Append($"{this.Module.BinaryOverlayClassName(loqui)}.{loqui.TargetObjectGeneration.Name}Factory(new {nameof(OverlayStream)}({DataAccessor(dataAccessor, $"_{typeGen.Name}Location!.Value.Min", $"_{typeGen.Name}Location!.Value.Max")}, _package), _package");
if (!recConverter.StartsWith("default("))
{
fg.Append($", {recConverter}");
}
fg.Append($") ");
fg.Append($": default;");
}
}
if (severalSubTypes)
{
using (new BraceWrapper(fg))
{
fg.AppendLine("get");
using (new BraceWrapper(fg))
{
fg.AppendLine($"if (!_{typeGen.Name}Location.HasValue) return default;");
fg.AppendLine($"switch (_{typeGen.Name}Type.TypeInt)");
using (new BraceWrapper(fg))
{
foreach (var gen in data.GenerationTypes)
{
if (!(gen.Value is LoquiType subLoq))
{
continue;
}
if (subLoq?.TargetObjectGeneration?.Abstract ?? false)
{
continue;
}
foreach (var trigger in gen.Key)
{
fg.AppendLine($"case 0x{trigger.TypeInt.ToString("X")}: // {trigger.Type}");
}
using (new DepthWrapper(fg))
using (new LineWrapper(fg))
{
fg.Append($"return {this.Module.BinaryOverlayClassName(subLoq)}.{subLoq.TargetObjectGeneration.Name}Factory(new {nameof(OverlayStream)}({DataAccessor(dataAccessor, $"_{subLoq.Name}Location!.Value.Min", $"_{subLoq.Name}Location!.Value.Max")}, _package), _package");
if (!loqui.Singleton)
{
fg.Append($", {recConverter}");
}
fg.Append($");");
}
}
fg.AppendLine("default:");
using (new DepthWrapper(fg))
{
fg.AppendLine("throw new ArgumentException();");
}
}
}
}
}
}
}
else
{
if (!loqui.Singleton)
{
fg.AppendLine($"public {loqui.Interface(getter: true, internalInterface: true)} {typeGen.Name} => {this.Module.BinaryOverlayClassName(loqui)}.{loqui.TargetObjectGeneration.Name}Factory(new {nameof(OverlayStream)}({dataAccessor}.Slice({passedLengthAccessor ?? "0x0"}), _package), _package, {recConverter});");
}
else
{
fg.AppendLine($"private {loqui.Interface(getter: true, internalInterface: true)} _{typeGen.Name} {{ get; private set; }}");
}
}
}
else
{
isRequiredRecord = true;
DataBinaryTranslationGeneration.GenerateWrapperExtraMembers(fg, dataType, objGen, typeGen, passedLengthAccessor);
fg.AppendLine($"private {loqui.Interface(getter: true, internalInterface: true)}? _{typeGen.Name} => _{typeGen.Name}_IsSet ? {this.Module.BinaryOverlayClassName(loqui)}.{loqui.TargetObjectGeneration.Name}Factory(new {nameof(OverlayStream)}({DataAccessor(dataAccessor, $"_{typeGen.Name}Location", null)}, _package), _package) : default;");
}
if (loqui.Singleton ||
isRequiredRecord)
{
fg.AppendLine($"public {loqui.Interface(getter: true, internalInterface: true)} {typeGen.Name} => _{typeGen.Name} ?? new {loqui.DirectTypeName}({(loqui.ThisConstruction ? "this" : null)});");
}
}
public override async Task GenerateInCommon(ObjectGeneration obj, FileGeneration fg, MaskTypeSet maskTypes)
{
bool getter = maskTypes.Applicable(LoquiInterfaceType.IGetter, CommonGenerics.Class);
bool setter = maskTypes.Applicable(LoquiInterfaceType.ISetter, CommonGenerics.Class);
if (!getter && !setter)
{
return;
}
var accessor = new Accessor("obj");
if (await MajorRecordModule.HasMajorRecordsInTree(obj, includeBaseClass: false) == Case.No)
{
return;
}
var overrideStr = await obj.FunctionOverride(async c => await MajorRecordModule.HasMajorRecords(c, includeBaseClass : false, includeSelf : true) != Case.No);
using (var args = new FunctionWrapper(fg,
$"public{overrideStr}IEnumerable<{nameof(IMajorRecordCommon)}{(getter ? "Getter" : null)}> EnumerateMajorRecords"))
{
args.Add($"{obj.Interface(getter: getter, internalInterface: true)} obj");
}
using (new BraceWrapper(fg))
{
if (setter)
{
fg.AppendLine($"foreach (var item in {obj.CommonClass(LoquiInterfaceType.IGetter, CommonGenerics.Class)}.Instance.EnumerateMajorRecords(obj))");
using (new BraceWrapper(fg))
{
fg.AppendLine($"yield return (item as {nameof(IMajorRecordCommon)})!;");
}
}
else
{
var fgCount = fg.Count;
foreach (var baseClass in obj.BaseClassTrail())
{
if (await MajorRecordModule.HasMajorRecords(baseClass, includeBaseClass: true, includeSelf: true) != Case.No)
{
fg.AppendLine("foreach (var item in base.EnumerateMajorRecords(obj))");
using (new BraceWrapper(fg))
{
fg.AppendLine("yield return item;");
}
break;
}
}
foreach (var field in obj.IterateFields())
{
switch (field)
{
case LoquiType _:
case ContainerType _:
case DictType _:
break;
default:
continue;
}
FileGeneration fieldFg = new FileGeneration();
if (field is LoquiType loqui)
{
var isMajorRecord = loqui.TargetObjectGeneration != null && await loqui.TargetObjectGeneration.IsMajorRecord();
if (isMajorRecord ||
await MajorRecordModule.HasMajorRecords(loqui, includeBaseClass: true) != Case.No)
{
var subFg = new FileGeneration();
var fieldAccessor = loqui.Nullable ? $"{loqui.Name}item" : $"{accessor}.{loqui.Name}";
await LoquiTypeHandler(subFg, fieldAccessor, loqui, generic : null, checkType : false);
if (subFg.Count == 0)
{
continue;
}
if (loqui.Singleton ||
!loqui.Nullable)
{
fieldFg.AppendLines(subFg);
}
else
{
fieldFg.AppendLine($"if ({accessor}.{loqui.Name}.TryGet(out var {loqui.Name}item))");
using (new BraceWrapper(fieldFg))
{
fieldFg.AppendLines(subFg);
}
}
}
}
else if (field is ContainerType cont)
{
if (!(cont.SubTypeGeneration is LoquiType contLoqui))
{
continue;
}
var isMajorRecord = contLoqui.TargetObjectGeneration != null && await contLoqui.TargetObjectGeneration.IsMajorRecord();
if (isMajorRecord ||
await MajorRecordModule.HasMajorRecords(contLoqui, includeBaseClass: true) != Case.No)
{
switch (await MajorRecordModule.HasMajorRecords(contLoqui, includeBaseClass: true))
{
case Case.Yes:
fieldFg.AppendLine($"foreach (var subItem in {accessor}.{field.Name}{(field.Nullable ? ".EmptyIfNull()" : null)})");
using (new BraceWrapper(fieldFg))
{
await LoquiTypeHandler(fieldFg, $"subItem", contLoqui, generic : null, checkType : false);
}
break;
case Case.Maybe:
fieldFg.AppendLine($"foreach (var subItem in {accessor}.{field.Name}{(field.Nullable ? ".EmptyIfNull()" : null)}.WhereCastable<{contLoqui.TypeName(getter: false)}, {(getter ? nameof(IMajorRecordGetterEnumerable) : nameof(IMajorRecordEnumerable))}>())");
using (new BraceWrapper(fieldFg))
{
await LoquiTypeHandler(fieldFg, $"subItem", contLoqui, generic : null, checkType : false);
}
break;
case Case.No:
default:
break;
}
}
}
else if (field is DictType dict)
{
if (dict.Mode != DictMode.KeyedValue)
{
continue;
}
if (!(dict.ValueTypeGen is LoquiType dictLoqui))
{
continue;
}
var isMajorRecord = dictLoqui.TargetObjectGeneration != null && await dictLoqui.TargetObjectGeneration.IsMajorRecord();
if (isMajorRecord ||
await MajorRecordModule.HasMajorRecords(dictLoqui, includeBaseClass: true) != Case.No)
{
switch (await MajorRecordModule.HasMajorRecords(dictLoqui, includeBaseClass: true))
{
case Case.Yes:
fieldFg.AppendLine($"foreach (var subItem in {accessor}.{field.Name}.Items)");
using (new BraceWrapper(fieldFg))
{
await LoquiTypeHandler(fieldFg, $"subItem", dictLoqui, generic : null, checkType : false);
}
break;
case Case.Maybe:
fieldFg.AppendLine($"foreach (var subItem in {accessor}.{field.Name}.Items.WhereCastable<{dictLoqui.TypeName(getter: false)}, {(getter ? nameof(IMajorRecordGetterEnumerable) : nameof(IMajorRecordEnumerable))}>())");
using (new BraceWrapper(fieldFg))
{
await LoquiTypeHandler(fieldFg, $"subItem", dictLoqui, generic : null, checkType : false);
}
break;
case Case.No:
default:
break;
}
}
}
if (fieldFg.Count > 0)
{
if (field.Nullable)
{
fg.AppendLine($"if ({field.NullableAccessor(getter: true, Accessor.FromType(field, accessor.ToString()))})");
}
using (new BraceWrapper(fg, doIt: field.Nullable))
{
fg.AppendLines(fieldFg);
}
}
}
if (fgCount == fg.Count)
{
fg.AppendLine("yield break;");
}
}
}
fg.AppendLine();
// Generate base overrides
foreach (var baseClass in obj.BaseClassTrail())
{
if (await MajorRecordModule.HasMajorRecords(baseClass, includeBaseClass: true, includeSelf: true) != Case.No)
{
using (var args = new FunctionWrapper(fg,
$"public override IEnumerable<{nameof(IMajorRecordCommon)}{(getter ? "Getter" : null)}> EnumerateMajorRecords"))
{
args.Add($"{baseClass.Interface(getter: getter)} obj");
}
using (new BraceWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
"EnumerateMajorRecords"))
{
args.Add($"({obj.Interface(getter: getter)})obj");
}
}
fg.AppendLine();
}
}
using (var args = new FunctionWrapper(fg,
$"public{overrideStr}IEnumerable<{nameof(IMajorRecordCommonGetter)}> EnumerateMajorRecords"))
{
args.Add($"{obj.Interface(getter: getter, internalInterface: true)} obj");
args.Add($"Type type");
args.Add($"bool throwIfUnknown");
}
using (new BraceWrapper(fg))
{
if (setter)
{
fg.AppendLine($"foreach (var item in {obj.CommonClass(LoquiInterfaceType.IGetter, CommonGenerics.Class)}.Instance.EnumerateMajorRecords(obj, type, throwIfUnknown))");
using (new BraceWrapper(fg))
{
fg.AppendLine("yield return item;");
}
}
else
{
var fgCount = fg.Count;
foreach (var baseClass in obj.BaseClassTrail())
{
if (await MajorRecordModule.HasMajorRecords(baseClass, includeBaseClass: true, includeSelf: true) != Case.No)
{
fg.AppendLine("foreach (var item in base.EnumerateMajorRecords<TMajor>(obj))");
using (new BraceWrapper(fg))
{
fg.AppendLine("yield return item;");
}
break;
}
}
fg.AppendLine("switch (type.Name)");
using (new BraceWrapper(fg))
{
var gameCategory = obj.GetObjectData().GameCategory;
fg.AppendLine($"case \"{nameof(IMajorRecordCommon)}\":");
fg.AppendLine($"case \"{nameof(IMajorRecord)}\":");
fg.AppendLine($"case \"{nameof(MajorRecord)}\":");
if (gameCategory != null)
{
fg.AppendLine($"case \"I{gameCategory}MajorRecord\":");
fg.AppendLine($"case \"{gameCategory}MajorRecord\":");
}
using (new DepthWrapper(fg))
{
fg.AppendLine($"if (!{obj.RegistrationName}.SetterType.IsAssignableFrom(obj.GetType())) yield break;");
fg.AppendLine("foreach (var item in this.EnumerateMajorRecords(obj))");
using (new BraceWrapper(fg))
{
fg.AppendLine("yield return item;");
}
fg.AppendLine("yield break;");
}
fg.AppendLine($"case \"{nameof(IMajorRecordGetter)}\":");
fg.AppendLine($"case \"{nameof(IMajorRecordCommonGetter)}\":");
if (gameCategory != null)
{
fg.AppendLine($"case \"I{gameCategory}MajorRecordGetter\":");
}
using (new DepthWrapper(fg))
{
fg.AppendLine("foreach (var item in this.EnumerateMajorRecords(obj))");
using (new BraceWrapper(fg))
{
fg.AppendLine("yield return item;");
}
fg.AppendLine("yield break;");
}
Dictionary <object, FileGeneration> generationDict = new Dictionary <object, FileGeneration>();
foreach (var field in obj.IterateFields())
{
FileGeneration fieldGen;
if (field is LoquiType loqui)
{
if (loqui.TargetObjectGeneration.IsListGroup())
{
continue;
}
var isMajorRecord = loqui.TargetObjectGeneration != null && await loqui.TargetObjectGeneration.IsMajorRecord();
if (!isMajorRecord &&
await MajorRecordModule.HasMajorRecords(loqui, includeBaseClass: true) == Case.No)
{
continue;
}
if (loqui.TargetObjectGeneration.GetObjectType() == ObjectType.Group)
{
fieldGen = generationDict.GetOrAdd(loqui.GetGroupTarget());
}
else
{
fieldGen = generationDict.GetOrAdd(((object)loqui?.TargetObjectGeneration) ?? loqui);
}
}
else if (field is ContainerType cont)
{
if (!(cont.SubTypeGeneration is LoquiType contLoqui))
{
continue;
}
if (contLoqui.RefType == LoquiType.LoquiRefType.Generic)
{
fieldGen = generationDict.GetOrAdd("default:");
}
else
{
fieldGen = generationDict.GetOrAdd(((object)contLoqui?.TargetObjectGeneration) ?? contLoqui);
}
}
else if (field is DictType dict)
{
if (dict.Mode != DictMode.KeyedValue)
{
continue;
}
if (!(dict.ValueTypeGen is LoquiType dictLoqui))
{
continue;
}
if (dictLoqui.RefType == LoquiType.LoquiRefType.Generic)
{
fieldGen = generationDict.GetOrAdd("default:");
}
else
{
fieldGen = generationDict.GetOrAdd(((object)dictLoqui?.TargetObjectGeneration) ?? dictLoqui);
}
}
else
{
continue;
}
await ApplyIterationLines(field, fieldGen, accessor, getter);
}
bool doAdditionlDeepLogic = obj.Name != "ListGroup";
if (doAdditionlDeepLogic)
{
var deepRecordMapping = await MajorRecordModule.FindDeepRecords(obj);
foreach (var deepRec in deepRecordMapping)
{
FileGeneration deepFg = generationDict.GetOrAdd(deepRec.Key);
foreach (var field in deepRec.Value)
{
await ApplyIterationLines(field, deepFg, accessor, getter, nickname : deepRec.Key.ObjectName);
}
}
HashSet <string> blackList = new HashSet <string>();
foreach (var kv in generationDict)
{
switch (kv.Key)
{
case LoquiType loqui:
if (loqui.RefType == LoquiType.LoquiRefType.Generic)
{
// Handled in default case
continue;
}
else
{
fg.AppendLine($"case \"{loqui.Interface(getter: true)}\":");
fg.AppendLine($"case \"{loqui.Interface(getter: false)}\":");
if (loqui.HasInternalGetInterface)
{
fg.AppendLine($"case \"{loqui.Interface(getter: true, internalInterface: true)}\":");
}
if (loqui.HasInternalSetInterface)
{
fg.AppendLine($"case \"{loqui.Interface(getter: false, internalInterface: true)}\":");
}
if (loqui.RefType == LoquiType.LoquiRefType.Interface)
{
blackList.Add(loqui.SetterInterface);
}
}
break;
case ObjectGeneration targetObj:
fg.AppendLine($"case \"{targetObj.ObjectName}\":");
fg.AppendLine($"case \"{targetObj.Interface(getter: true)}\":");
fg.AppendLine($"case \"{targetObj.Interface(getter: false)}\":");
if (targetObj.HasInternalGetInterface)
{
fg.AppendLine($"case \"{targetObj.Interface(getter: true, internalInterface: true)}\":");
}
if (targetObj.HasInternalSetInterface)
{
fg.AppendLine($"case \"{targetObj.Interface(getter: false, internalInterface: true)}\":");
}
break;
case string str:
if (str != "default:")
{
throw new NotImplementedException();
}
continue;
default:
throw new NotImplementedException();
}
using (new DepthWrapper(fg))
{
fg.AppendLines(kv.Value);
fg.AppendLine("yield break;");
}
}
// Generate for major record marker interfaces
if (LinkInterfaceModule.ObjectMappings.TryGetValue(obj.ProtoGen.Protocol, out var interfs))
{
foreach (var interf in interfs)
{
if (blackList.Contains(interf.Key))
{
continue;
}
FileGeneration subFg = new FileGeneration();
HashSet <ObjectGeneration> passedObjects = new HashSet <ObjectGeneration>();
HashSet <TypeGeneration> deepObjects = new HashSet <TypeGeneration>();
foreach (var subObj in interf.Value)
{
var grup = obj.Fields
.WhereCastable <TypeGeneration, GroupType>()
.Where(g => g.GetGroupTarget() == subObj)
.FirstOrDefault();
if (grup != null)
{
subFg.AppendLine($"foreach (var item in EnumerateMajorRecords({accessor}, typeof({grup.GetGroupTarget().Interface(getter: true)}), throwIfUnknown: throwIfUnknown))");
using (new BraceWrapper(subFg))
{
subFg.AppendLine("yield return item;");
}
passedObjects.Add(grup.GetGroupTarget());
}
else if (deepRecordMapping.TryGetValue(subObj, out var deepRec))
{
foreach (var field in deepRec)
{
deepObjects.Add(field);
}
}
}
foreach (var deepObj in deepObjects)
{
await ApplyIterationLines(deepObj, subFg, accessor, getter, blackList : passedObjects);
}
if (!subFg.Empty)
{
fg.AppendLine($"case \"{interf.Key}\":");
using (new BraceWrapper(fg))
{
fg.AppendLine($"if (!{obj.RegistrationName}.SetterType.IsAssignableFrom(obj.GetType())) yield break;");
fg.AppendLines(subFg);
fg.AppendLine("yield break;");
}
fg.AppendLine($"case \"{interf.Key}Getter\":");
using (new BraceWrapper(fg))
{
fg.AppendLines(subFg);
fg.AppendLine("yield break;");
}
}
}
}
}
fg.AppendLine("default:");
using (new DepthWrapper(fg))
{
if (generationDict.TryGetValue("default:", out var gen))
{
fg.AppendLines(gen);
fg.AppendLine("yield break;");
}
else
{
fg.AppendLine("if (throwIfUnknown)");
using (new BraceWrapper(fg))
{
fg.AppendLine("throw new ArgumentException($\"Unknown major record type: {type}\");");
}
fg.AppendLine($"else");
using (new BraceWrapper(fg))
{
fg.AppendLine("yield break;");
}
}
}
}
}
}
fg.AppendLine();
// Generate base overrides
foreach (var baseClass in obj.BaseClassTrail())
{
if (await MajorRecordModule.HasMajorRecords(baseClass, includeBaseClass: true, includeSelf: true) != Case.No)
{
using (var args = new FunctionWrapper(fg,
$"public override IEnumerable<TMajor> EnumerateMajorRecords<TMajor>"))
{
args.Add($"{baseClass.Interface(getter: getter)} obj");
args.Wheres.Add($"where TMajor : {nameof(IMajorRecordCommon)}{(getter ? "Getter" : null)}");
}
using (new BraceWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
"EnumerateMajorRecords<TMajor>"))
{
args.Add($"({obj.Interface(getter: getter)})obj");
}
}
fg.AppendLine();
}
}
}
public override bool AllowDirectWrite(ObjectGeneration objGen, TypeGeneration typeGen)
{
return(false);
}
public override bool Test(ObjectGeneration o, Dictionary <string, TypeGeneration> allFields) => allFields
.TryGetValue("ObjectBounds", out var field) &&
field is LoquiType loqui &&
public override async Task <int?> ExpectedLength(ObjectGeneration objGen, TypeGeneration typeGen)
{
var data = typeGen.GetFieldData();
if (data.Length.HasValue)
{
return(data.Length);
}
LoquiType loqui = typeGen as LoquiType;
if (loqui.TargetObjectGeneration == null)
{
return(null);
}
var sum = 0;
foreach (var item in loqui.TargetObjectGeneration.IterateFields(includeBaseClass: true))
{
if (item.Nullable)
{
return(null);
}
if (!this.Module.TryGetTypeGeneration(item.GetType(), out var gen))
{
continue;
}
var len = await gen.ExpectedLength(loqui.TargetObjectGeneration, item);
if (len == null)
{
return(null);
}
sum += len.Value;
}
if (loqui.TargetObjectGeneration.Abstract)
{
int?absSum = null;
foreach (var inheritingObj in await loqui.TargetObjectGeneration.InheritingObjects())
{
int objectSum = 0;
foreach (var item in inheritingObj.IterateFields(includeBaseClass: true))
{
if (item.Nullable)
{
return(null);
}
if (!this.Module.TryGetTypeGeneration(item.GetType(), out var gen))
{
continue;
}
var len = await gen.ExpectedLength(inheritingObj, item);
if (len == null)
{
return(null);
}
objectSum += len.Value;
}
if (absSum == null)
{
absSum = objectSum;
}
else if (absSum.Value != objectSum)
{
// Inheriting objects don't agree on their length, so we can't expect a certain length
return(null);
}
}
if (absSum == null)
{
return(null);
}
sum += absSum.Value;
}
return(sum);
}
public override async Task GenerateWrapperFields(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor dataAccessor,
int?currentPosition,
string passedLengthAccessor,
DataType dataType)
{
var eType = typeGen as EnumType;
var data = typeGen.GetFieldData();
var nullable = typeGen.Nullable && eType.NullableFallbackInt == null;
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 (dataType == null && data.HasVersioning && !typeGen.Nullable)
{
fg.AppendLine($"private bool _{typeGen.Name}_IsSet => {VersioningModule.GetVersionIfCheck(data, "_package.FormVersion!.FormVersion!.Value")};");
}
if (data.HasTrigger)
{
fg.AppendLine($"private int? _{typeGen.Name}Location;");
}
var posStr = dataType == null ? passedLengthAccessor : $"_{typeGen.Name}Location";
posStr ??= "0x0";
string slice;
if (data.RecordType.HasValue)
{
slice = $"{nameof(HeaderTranslation)}.{nameof(HeaderTranslation.ExtractSubrecordMemory)}({dataAccessor}, _{typeGen.Name}Location!.Value, _package.{nameof(BinaryOverlayFactoryPackage.MetaData)}.{nameof(ParsingBundle.Constants)})";
}
else
{
slice = $"{dataAccessor}.Span.Slice({posStr}, 0x{eType.ByteLength:X})";
}
var getType = GenerateForTypicalWrapper(objGen, typeGen, slice, "_package");
if (dataType != null)
{
DataBinaryTranslationGeneration.GenerateWrapperExtraMembers(fg, dataType, objGen, typeGen, passedLengthAccessor);
}
bool isSetCheck = dataType != null || data.HasVersioning;
if (eType.NullableFallbackInt != null)
{
fg.AppendLine($"public {eType.TypeName(getter: true)}? {eType.Name}");
using (new BraceWrapper(fg))
{
fg.AppendLine("get");
using (new BraceWrapper(fg))
{
fg.AppendLine($"var val = {getType};");
fg.AppendLine($"if (((int)val) == {eType.NullableFallbackInt}) return null;");
fg.AppendLine("return val;");
}
}
}
else if (data.HasTrigger)
{
if (typeGen.CanBeNullable(getter: true))
{
fg.AppendLine($"public {eType.TypeName(getter: true)}{(nullable ? "?" : null)} {eType.Name} => _{typeGen.Name}Location.HasValue ? {getType} : default({eType.TypeName(getter: true)}{(nullable ? "?" : null)});");
}
else
{
fg.AppendLine($"public {eType.TypeName(getter: true)} {eType.Name} => {getType};");
}
}
else
{
if (!isSetCheck)
{
if (data.IsAfterBreak)
{
fg.AppendLine($"public {eType.TypeName(getter: true)} {eType.Name} => {dataAccessor}.Span.Length <= {posStr} ? default : {getType};");
}
else
{
fg.AppendLine($"public {eType.TypeName(getter: true)} {eType.Name} => {getType};");
}
}
else
{
fg.AppendLine($"public {eType.TypeName(getter: true)} {eType.Name} => _{typeGen.Name}_IsSet ? {getType} : default;");
}
}
}
private string GetLocationObjectString(ObjectGeneration obj) => obj.GetObjectType() == ObjectType.Mod ? nameof(RangeInt64) : nameof(RangeInt32);
public override async Task <int?> ExpectedLength(ObjectGeneration objGen, TypeGeneration typeGen)
{
var eType = typeGen as EnumType;
return(eType.ByteLength);
}
public override async Task GenerateWrapperRecordTypeParse(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor locationAccessor,
Accessor packageAccessor,
Accessor converterAccessor)
{
LoquiType loqui = typeGen as LoquiType;
var data = loqui.GetFieldData();
switch (data.BinaryOverlayFallback)
{
case BinaryGenerationType.Normal:
break;
case BinaryGenerationType.NoGeneration:
return;
case BinaryGenerationType.Custom:
using (var args = new ArgsWrapper(fg,
$"{typeGen.Name}CustomParse"))
{
args.Add("stream");
args.Add("finalPos");
args.Add("offset");
}
return;
default:
throw new NotImplementedException();
}
string accessor;
if (loqui.Singleton ||
!loqui.Nullable)
{
accessor = $"_{typeGen.Name}";
}
else
{
accessor = typeGen.Name;
}
if (data.MarkerType.HasValue)
{
fg.AppendLine($"stream.Position += {packageAccessor}.{nameof(BinaryOverlayFactoryPackage.MetaData)}.{nameof(ParsingBundle.Constants)}.SubConstants.HeaderLength; // Skip marker");
}
if (!loqui.TargetObjectGeneration.IsTypelessStruct() && (loqui.GetFieldData()?.HasTrigger ?? false))
{
fg.AppendLine($"_{typeGen.Name}Location = new {GetLocationObjectString(objGen)}({locationAccessor}, finalPos);");
var severalSubTypes = data.GenerationTypes
.Select(i => i.Value)
.WhereCastable <TypeGeneration, LoquiType>()
.Where(loqui => !loqui?.TargetObjectGeneration?.Abstract ?? true)
.CountGreaterThan(1);
if (severalSubTypes)
{
fg.AppendLine($"_{typeGen.Name}Type = type;");
}
}
else
{
if (NeedsHeaderProcessing(loqui))
{
fg.AppendLine($"stream.Position += _package.{nameof(BinaryOverlayFactoryPackage.MetaData)}.{nameof(ParsingBundle.Constants)}.SubConstants.HeaderLength;");
}
using (var args = new ArgsWrapper(fg,
$"this.{accessor} = {this.Module.BinaryOverlayClassName(loqui)}.{loqui.TargetObjectGeneration.Name}Factory"))
{
args.Add($"stream: stream");
args.Add($"package: {packageAccessor}");
if (loqui.TargetObjectGeneration.IsVariableLengthStruct())
{
args.AddPassArg($"finalPos");
}
args.Add($"recordTypeConverter: {converterAccessor}");
}
}
}
public override async IAsyncEnumerable <string> RequiredUsingStatements(ObjectGeneration obj)
{
yield return("System.Threading.Tasks");
yield return("Noggog.Utility");
}
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}");
}
}
}
}
}
}
private async Task GenerateForMod(ObjectGeneration obj, FileGeneration fg)
{
using (var args = new FunctionWrapper(fg,
$"public static Task<{obj.Name}> CreateFromXmlFolder"))
{
args.Add("DirectoryPath dir");
args.Add("ModKey modKey");
}
using (new BraceWrapper(fg))
{
using (var args = new ArgsWrapper(fg,
"return CreateFromXmlFolder"))
{
args.Add("dir: dir");
args.Add("modKey: modKey");
args.Add("errorMask: null");
}
}
fg.AppendLine();
using (var args = new FunctionWrapper(fg,
$"public static async Task<({obj.Name} Mod, {obj.Mask(MaskType.Error)} ErrorMask)> CreateFromXmlFolderWithErrorMask"))
{
args.Add("DirectoryPath dir");
args.Add("ModKey modKey");
}
using (new BraceWrapper(fg))
{
fg.AppendLine("ErrorMaskBuilder? errorMaskBuilder = new ErrorMaskBuilder();");
using (var args = new ArgsWrapper(fg,
"var ret = await CreateFromXmlFolder"))
{
args.Add("dir: dir");
args.Add("modKey: modKey");
args.Add("errorMask: errorMaskBuilder");
}
fg.AppendLine($"var errorMask = {obj.Mask(MaskType.Error)}.Factory(errorMaskBuilder);");
fg.AppendLine("return (ret, errorMask);");
}
fg.AppendLine();
using (var args = new FunctionWrapper(fg,
$"public static async Task<{obj.Name}> CreateFromXmlFolder"))
{
args.Add("DirectoryPath dir");
args.Add("ModKey modKey");
args.Add("ErrorMaskBuilder? errorMask");
}
using (new BraceWrapper(fg))
{
fg.AppendLine($"var item = new {obj.Name}(modKey);");
fg.AppendLine($"var tasks = new List<Task>();");
foreach (var field in obj.IterateFields())
{
if (field.GetFieldData().CustomFolder)
{
using (var args = new ArgsWrapper(fg,
$"tasks.Add(Task.Run(() => item.CreateFromXmlFolder{field.Name}",
suffixLine: "))"))
{
args.Add("dir: dir");
args.Add($"name: nameof({field.Name})");
args.Add($"index: (int){field.IndexEnumName}");
args.Add($"errorMask: errorMask");
}
continue;
}
if (!(field is LoquiType loqui))
{
throw new ArgumentException();
}
switch (loqui.TargetObjectGeneration.GetObjectType())
{
case ObjectType.Record:
using (var args = new ArgsWrapper(fg,
$"item.{field.Name}.CopyInFromXml"))
{
args.Add($"path: Path.Combine(dir.Path, \"{field.Name}.xml\")");
args.Add($"errorMask: errorMask");
args.Add($"translationMask: null");
}
break;
case ObjectType.Group:
if (!loqui.TryGetSpecificationAsObject("T", out var subObj))
{
continue;
}
using (var args = new ArgsWrapper(fg,
$"tasks.Add(Task.Run(() => item.{field.Name}.CreateFromXmlFolder<{subObj.Name}>",
suffixLine: "))"))
{
args.Add($"dir: dir");
args.Add($"name: nameof({field.Name})");
args.Add($"errorMask: errorMask");
args.Add($"index: (int){field.IndexEnumName}");
}
break;
default:
break;
}
}
fg.AppendLine("await Task.WhenAll(tasks);");
fg.AppendLine("return item;");
}
fg.AppendLine();
using (var args = new FunctionWrapper(fg,
$"public async Task<{obj.Mask(MaskType.Error)}?> WriteToXmlFolder"))
{
args.Add("DirectoryPath dir");
args.Add("bool doMasks = true");
}
using (new BraceWrapper(fg))
{
fg.AppendLine($"ErrorMaskBuilder? errorMaskBuilder = null;");
fg.AppendLine("dir.Create();");
fg.AppendLine("using (new FolderCleaner(dir, FolderCleaner.CleanType.AccessTime))");
using (new BraceWrapper(fg))
{
fg.AppendLine($"var tasks = new List<Task>();");
foreach (var field in obj.IterateFields())
{
if (!(field is LoquiType loqui))
{
throw new ArgumentException();
}
if (field.GetFieldData().CustomFolder)
{
using (var args = new ArgsWrapper(fg,
$"tasks.Add(Task.Run(() => WriteToXmlFolder{field.Name}",
suffixLine: "))"))
{
args.Add("dir: dir");
args.Add($"name: nameof({field.Name})");;
args.Add($"index: (int){field.IndexEnumName}");
args.Add($"errorMask: errorMaskBuilder");
}
continue;
}
switch (loqui.TargetObjectGeneration.GetObjectType())
{
case ObjectType.Record:
using (var args = new ArgsWrapper(fg,
$"tasks.Add(Task.Run(() => this.{field.Name}.WriteToXml",
suffixLine: "))"))
{
args.Add($"path: Path.Combine(dir.Path, \"{field.Name}.xml\")");
args.Add($"errorMask: errorMaskBuilder");
args.Add($"translationMask: null");
}
break;
case ObjectType.Group:
ObjectGeneration subObj;
if (field is GroupType group)
{
if (!group.TryGetSpecificationAsObject("T", out subObj))
{
continue;
}
using (var args = new ArgsWrapper(fg,
$"tasks.Add(Task.Run(() => {field.Name}.WriteToXmlFolder<{subObj.Name}, {subObj.Mask(MaskType.Error)}>",
suffixLine: "))"))
{
args.Add($"dir: dir.Path");
args.Add($"name: nameof({field.Name})");
args.Add($"errorMask: errorMaskBuilder");
args.Add($"index: (int){field.IndexEnumName}");
}
}
else
{
using (var args = new ArgsWrapper(fg,
$"tasks.Add(Task.Run(() => {field.Name}.WriteToXmlFolder",
suffixLine: "))"))
{
args.Add($"dir: dir.Path");
args.Add($"name: nameof({field.Name})");
args.Add($"errorMask: errorMaskBuilder");
args.Add($"index: (int){field.IndexEnumName}");
}
}
break;
default:
break;
}
}
fg.AppendLine("await Task.WhenAll(tasks);");
}
fg.AppendLine("return null;");
}
}
private void GenerateWriteParallel(ObjectGeneration obj, FileGeneration fg)
{
LoquiType groupInstance = null;
LoquiType listGroupInstance = null;
var objData = obj.GetObjectData();
fg.AppendLine("const int CutCount = 100;");
using (var args = new FunctionWrapper(fg,
"public static void WriteParallel"))
{
args.Add($"{obj.Interface(getter: true, internalInterface: false)} item");
args.Add($"Stream stream");
args.Add($"{nameof(BinaryWriteParameters)} param");
args.Add($"ModKey modKey");
}
using (new BraceWrapper(fg))
{
string gameConstantsStr;
if (objData.GameReleaseOptions == null)
{
gameConstantsStr = $"{nameof(GameConstants)}.{obj.GetObjectData().GameCategory}";
}
else
{
fg.AppendLine($"var gameConstants = {nameof(GameConstants)}.Get(item.{ReleaseEnumName(obj)}.ToGameRelease());");
gameConstantsStr = $"gameConstants";
}
fg.AppendLine($"var bundle = new {nameof(WritingBundle)}({gameConstantsStr});");
fg.AppendLine($"var writer = new MutagenWriter(stream, bundle);");
using (var args = new ArgsWrapper(fg,
$"{nameof(ModHeaderWriteLogic)}.{nameof(ModHeaderWriteLogic.WriteHeader)}"))
{
args.AddPassArg("param");
args.AddPassArg("writer");
args.Add("mod: item");
args.Add("modHeader: item.ModHeader.DeepCopy()");
args.AddPassArg("modKey");
}
int groupCount = obj.IterateFields()
.Select(f => f as LoquiType)
.Where(l => l != null)
.Where(l => l.TargetObjectGeneration?.GetObjectData().ObjectType == ObjectType.Group)
.Count();
fg.AppendLine($"Stream[] outputStreams = new Stream[{groupCount}];");
fg.AppendLine($"List<Action> toDo = new List<Action>();");
int i = 0;
foreach (var field in obj.IterateFields())
{
if (!(field is LoquiType loqui))
{
continue;
}
if (loqui.TargetObjectGeneration?.GetObjectData().ObjectType != ObjectType.Group)
{
continue;
}
if (loqui.TargetObjectGeneration.Name == "ListGroup")
{
listGroupInstance = loqui;
}
else
{
groupInstance = loqui;
}
if (loqui.GetGroupTarget().GetObjectData().CustomBinaryEnd == CustomEnd.Off &&
loqui.TargetObjectGeneration.Name != "ListGroup")
{
fg.AppendLine($"toDo.Add(() => WriteGroupParallel(item.{field.Name}, writer.MetaData.MasterReferences!, {i}{(objData.GameReleaseOptions == null ? null : ", gameConstants")}, outputStreams{(objData.UsesStringFiles ? ", param.StringsWriter" : null)}));");
}
else
{
fg.AppendLine($"toDo.Add(() => Write{field.Name}Parallel(item.{field.Name}, writer.MetaData.MasterReferences!, {i}{(objData.GameReleaseOptions == null ? null : ", gameConstants")}, outputStreams));");
}
i++;
}
fg.AppendLine("Parallel.Invoke(toDo.ToArray());");
using (var args = new ArgsWrapper(fg,
$"{nameof(PluginUtilityTranslation)}.{nameof(PluginUtilityTranslation.CompileStreamsInto)}"))
{
args.Add("outputStreams.NotNull()");
args.Add("stream");
}
}
fg.AppendLine();
if (groupInstance != null)
{
using (var args = new FunctionWrapper(fg,
$"public static void WriteGroupParallel<T>"))
{
args.Add("IGroupGetter<T> group");
args.Add($"{nameof(MasterReferenceReader)} masters");
args.Add("int targetIndex");
if (objData.GameReleaseOptions != null)
{
args.Add($"{nameof(GameConstants)} gameConstants");
}
args.Add("Stream[] streamDepositArray");
if (objData.UsesStringFiles)
{
args.Add($"{nameof(StringsWriter)}? stringsWriter");
}
args.Wheres.AddRange(groupInstance.TargetObjectGeneration.GenerateWhereClauses(LoquiInterfaceType.IGetter, groupInstance.TargetObjectGeneration.Generics));
}
using (new BraceWrapper(fg))
{
string gameConstantsStr;
if (objData.GameReleaseOptions == null)
{
gameConstantsStr = $"{nameof(GameConstants)}.{obj.GetObjectData().GameCategory}";
}
else
{
gameConstantsStr = "gameConstants";
}
fg.AppendLine("if (group.RecordCache.Count == 0) return;");
fg.AppendLine($"var cuts = group.Cut(CutCount).ToArray();");
fg.AppendLine($"Stream[] subStreams = new Stream[cuts.Length + 1];");
fg.AppendLine($"byte[] groupBytes = new byte[{gameConstantsStr}.GroupConstants.HeaderLength];");
fg.AppendLine($"BinaryPrimitives.WriteInt32LittleEndian(groupBytes.AsSpan(), RecordTypes.GRUP.TypeInt);");
fg.AppendLine($"var groupByteStream = new MemoryStream(groupBytes);");
fg.AppendLine($"using (var stream = new MutagenWriter(groupByteStream, {gameConstantsStr}, dispose: false))");
using (new BraceWrapper(fg))
{
fg.AppendLine($"stream.Position += 8;");
fg.AppendLine($"GroupBinaryWriteTranslation.WriteEmbedded<T>(group, stream);");
}
fg.AppendLine($"subStreams[0] = groupByteStream;");
fg.AppendLine($"Parallel.ForEach(cuts, (cutItems, state, counter) =>");
using (new BraceWrapper(fg)
{
AppendSemicolon = true, AppendParenthesis = true
})
{
fg.AppendLine($"{nameof(MemoryTributary)} trib = new {nameof(MemoryTributary)}();");
fg.AppendLine($"var bundle = new {nameof(WritingBundle)}({gameConstantsStr})");
using (var prop = new PropertyCtorWrapper(fg))
{
prop.Add($"{nameof(WritingBundle.MasterReferences)} = masters");
if (objData.UsesStringFiles)
{
prop.Add($"{nameof(WritingBundle.StringsWriter)} = stringsWriter");
}
}
fg.AppendLine($"using (var stream = new MutagenWriter(trib, bundle, dispose: false))");
using (new BraceWrapper(fg))
{
fg.AppendLine($"foreach (var item in cutItems)");
using (new BraceWrapper(fg))
{
fg.AppendLine($"item.WriteToBinary(stream);");
}
}
fg.AppendLine($"subStreams[(int)counter + 1] = trib;");
}
fg.AppendLine($"{nameof(PluginUtilityTranslation)}.CompileSetGroupLength(subStreams, groupBytes);");
fg.AppendLine($"streamDepositArray[targetIndex] = new CompositeReadStream(subStreams, resetPositions: true);");
}
fg.AppendLine();
}
}
