public override async Task GenerateInClass(ObjectGeneration obj, FileGeneration fg)
{
var enumTypes = new List <string>();
var breaks = 0;
foreach (var field in obj.Fields)
{
if (field is BreakType breakType)
{
enumTypes.Add("Break" + breaks++);
}
}
if (enumTypes.Count <= 0)
{
return;
}
fg.AppendLine("[Flags]");
fg.AppendLine($"public enum {VersioningEnumName}");
using (new BraceWrapper(fg))
{
using (var comma = new CommaWrapper(fg))
{
var term = 1;
for (int i = 0; i < enumTypes.Count; i++)
{
comma.Add($"{enumTypes[i]} = {term}");
term *= 2;
}
}
}
}
public override async Task GenerateInRegistration(ObjectGeneration obj, FileGeneration fg)
{
HashSet <RecordType> trigRecordTypes = new HashSet <RecordType>();
var data = obj.GetObjectData();
trigRecordTypes.Add((await data.GenerationTypes).SelectMany((kv) => kv.Key));
var count = trigRecordTypes.Count();
if (obj.Name.EndsWith("MajorRecord"))
{
return;
}
if (count == 1)
{
fg.AppendLine($"public static readonly {nameof(RecordType)} {Mutagen.Bethesda.Internals.Constants.TriggeringRecordTypeMember} = {obj.RecordTypeHeaderName(trigRecordTypes.First())};");
}
else if (count > 1)
{
fg.AppendLine($"public static ICollectionGetter<RecordType> TriggeringRecordTypes => _TriggeringRecordTypes.Value;");
fg.AppendLine($"private static readonly Lazy<ICollectionGetter<RecordType>> _TriggeringRecordTypes = new Lazy<ICollectionGetter<RecordType>>(() =>");
using (new BraceWrapper(fg)
{
AppendSemicolon = true, AppendParenthesis = true
})
{
fg.AppendLine($"return new CollectionGetterWrapper<RecordType>(");
using (new DepthWrapper(fg))
{
fg.AppendLine("new HashSet<RecordType>(");
using (new DepthWrapper(fg))
{
fg.AppendLine($"new RecordType[]");
using (new BraceWrapper(fg)
{
AppendParenthesis = true
})
{
using (var comma = new CommaWrapper(fg))
{
foreach (var trigger in trigRecordTypes)
{
comma.Add($"{obj.RecordTypeHeaderName(trigger)}");
}
}
}
}
}
fg.AppendLine(");");
}
}
await base.GenerateInRegistration(obj, fg);
}
public override async Task GenerateInClass(ObjectGeneration obj, FileGeneration fg)
{
await base.GenerateInClass(obj, fg);
List <string> enumTypes;
int breaks;
foreach (var field in obj.IterateFields(expandSets: SetMarkerType.ExpandSets.FalseAndInclude))
{
if (!(field is DataType dataType))
{
continue;
}
enumTypes = new List <string>();
breaks = 0;
int ranges = 0;
foreach (var node in dataType.Node.Element(XName.Get(Loqui.Generation.Constants.FIELDS, LoquiGenerator.Namespace)).Elements())
{
switch (node.Name.LocalName)
{
case DataType.BREAK:
enumTypes.Add("Break" + breaks++);
break;
case DataType.RANGE:
enumTypes.Add("Range" + ranges++);
break;
default:
break;
}
}
fg.AppendLine("[Flags]");
fg.AppendLine($"public enum {dataType.EnumName}");
using (new BraceWrapper(fg))
{
using (var comma = new CommaWrapper(fg))
{
var term = 1;
for (int i = 0; i < enumTypes.Count; i++)
{
comma.Add($"{enumTypes[i]} = {term}");
term *= 2;
}
}
}
}
}
public override async Task GenerateInVoid(ObjectGeneration obj, FileGeneration fg)
{
if (obj.GetObjectType() != ObjectType.Mod)
{
return;
}
using (new NamespaceWrapper(fg, obj.Namespace))
{
var objData = obj.GetObjectData();
fg.AppendLine("public class GroupMask");
using (new BraceWrapper(fg))
{
foreach (var field in obj.IterateFields())
{
if (!(field is LoquiType loqui))
{
continue;
}
if (loqui.TargetObjectGeneration == null)
{
continue;
}
if (loqui.TargetObjectGeneration.GetObjectType() != ObjectType.Group)
{
continue;
}
fg.AppendLine($"public bool {loqui.Name};");
}
fg.AppendLine("public GroupMask()");
using (new BraceWrapper(fg))
{
}
fg.AppendLine("public GroupMask(bool defaultValue)");
using (new BraceWrapper(fg))
{
foreach (var field in obj.IterateFields())
{
if (!(field is LoquiType loqui))
{
continue;
}
if (loqui.TargetObjectGeneration == null)
{
continue;
}
if (loqui.TargetObjectGeneration.GetObjectType() != ObjectType.Group)
{
continue;
}
fg.AppendLine($"{loqui.Name} = defaultValue;");
}
}
}
fg.AppendLine();
fg.AppendLine($"public interface I{obj.Name}DisposableGetter : {obj.Interface(getter: true, internalInterface: true)}, IModDisposeGetter");
using (new BraceWrapper(fg))
{
}
fg.AppendLine();
if (objData.GameReleaseOptions != null)
{
using (var comment = new CommentWrapper(fg))
{
comment.Summary.AppendLine($"Different game release versions a {ModName(obj)} mod can have");
}
fg.AppendLine($"public enum {ReleaseEnumName(obj)}");
using (new BraceWrapper(fg))
{
using (var comma = new CommaWrapper(fg))
{
foreach (var opt in objData.GameReleaseOptions)
{
comma.Add($"{opt} = {(int)opt}");
}
}
}
fg.AppendLine();
using (var c = new ClassWrapper(fg, $"{ReleaseEnumName(obj)}Ext"))
{
c.Static = true;
}
using (new BraceWrapper(fg))
{
using (var args = new FunctionWrapper(fg,
$"public static {nameof(GameRelease)} ToGameRelease"))
{
args.Add($"this {ReleaseEnumName(obj)} release");
}
using (new BraceWrapper(fg))
{
fg.AppendLine("return release switch");
using (new BraceWrapper(fg)
{
AppendSemicolon = true
})
{
using (var comma = new CommaWrapper(fg))
{
foreach (var item in objData.GameReleaseOptions)
{
comma.Add($"{ReleaseEnumName(obj)}.{item} => {nameof(GameRelease)}.{item}");
}
comma.Add("_ => throw new ArgumentException()");
}
}
}
fg.AppendLine();
using (var args = new FunctionWrapper(fg,
$"public static {ReleaseEnumName(obj)} To{ReleaseEnumName(obj)}"))
{
args.Add($"this {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 item in objData.GameReleaseOptions)
{
comma.Add($"{nameof(GameRelease)}.{item} => {ReleaseEnumName(obj)}.{item}");
}
comma.Add("_ => throw new ArgumentException()");
}
}
}
}
}
}
}
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));
}
