protected override async Task GenerateWriteSnippet(ObjectGeneration obj, StructuredStringBuilder sb)
{
sb.AppendLine($"var elem = new XElement(name ?? \"{obj.FullName}\");");
sb.AppendLine($"{XElementLine.GetParameterName(obj, Context.Backend)}.Add(elem);");
sb.AppendLine("if (name != null)");
using (sb.CurlyBrace())
{
sb.AppendLine($"elem.SetAttributeValue(\"{XmlConstants.TYPE_ATTRIBUTE}\", \"{obj.FullName}\");");
}
using (var args = sb.Call(
$"WriteToNode{ModuleNickname}"))
{
args.Add($"item: item");
args.Add($"{XElementLine.GetParameterName(obj, Context.Backend)}: elem");
foreach (var item in MainAPI.ReaderAPI.CustomAPI)
{
if (!item.API.TryGetPassthrough(obj, TranslationDirection.Reader, Context.Backend, out var passthrough))
{
continue;
}
args.Add(passthrough);
}
args.Add($"errorMask: errorMask");
args.Add($"translationMask: translationMask");
}
}
protected override async Task GenerateCtor(StructuredStringBuilder sb)
{
if (BasicCtorPermission == CtorPermissionLevel.noGeneration)
{
return;
}
using (sb.Region("Ctor"))
{
sb.AppendLine($"{BasicCtorPermission.ToStringFast_Enum_Only()} {Name}()");
using (sb.CurlyBrace())
{
List <Task> toDo = new List <Task>();
toDo.AddRange(gen.GenerationModules.Select(mod => mod.GenerateInCtor(this, sb)));
var fieldsTask = Task.WhenAll(IterateFields().Select(field => field.GenerateForCtor(sb)));
toDo.Add(fieldsTask);
await fieldsTask;
fieldCtorsGenerated.SetResult();
await Task.WhenAll(toDo);
await GenerateInitializer(sb);
sb.AppendLine("CustomCtor();");
}
sb.AppendLine("partial void CustomCtor();");
}
}
public static void Print <TOverall, TSpecific>(this MaskItem <TOverall, TSpecific> maskItem, StructuredStringBuilder sb)
{
if (maskItem.Overall != null)
{
if (maskItem.Overall is IPrintable printable)
{
printable.Print(sb, null);
}
else
{
sb.AppendLine(maskItem.Overall.ToString());
}
}
if (maskItem.Specific != null)
{
if (maskItem.Specific is IPrintable printable)
{
printable.Print(sb, null);
}
else
{
sb.AppendLine(maskItem.Specific.ToString());
}
}
}
public override void GenerateForCopy(StructuredStringBuilder sb, Accessor accessor, Accessor rhs, Accessor copyMaskAccessor, bool protectedMembers, bool deepCopy)
{
if (FixedSize.HasValue && SubTypeGeneration is not LoquiType)
{
if (!AlwaysCopy)
{
sb.AppendLine($"if ({(deepCopy ? GetTranslationIfAccessor(copyMaskAccessor) : SkipCheck(copyMaskAccessor, deepCopy))})");
}
using (sb.CurlyBrace(doIt: !AlwaysCopy))
{
if (Nullable)
{
sb.AppendLine($"{accessor} = {rhs}?.ToArray();");
}
else
{
sb.AppendLine($"{rhs}.Span.CopyTo({accessor}.AsSpan());");
}
}
}
else
{
base.GenerateForCopy(sb, accessor, rhs, copyMaskAccessor, protectedMembers, deepCopy);
}
}
private void WrapSetAccessor(
StructuredStringBuilder sb,
string linePrefix,
Action <StructuredStringBuilder> toDo)
{
StructuredStringBuilder subFg = new StructuredStringBuilder();
WrapSetCode(subFg, toDo);
if (subFg.Count > 1)
{
sb.AppendLine(linePrefix);
using (sb.CurlyBrace())
{
sb.AppendLines(subFg);
}
}
else if (subFg.Count > 0)
{
sb.AppendLine($"{linePrefix} => {subFg[0]}");
}
else
{
sb.AppendLine($"{linePrefix}");
}
}
public override void GenerateClear(StructuredStringBuilder sb, Accessor identifier)
{
if (ReadOnly || !IntegrateField)
{
return;
}
// ToDo
// Add internal interface support
if (InternalSetInterface)
{
return;
}
if (HasDefault)
{
sb.AppendLine($"{identifier.Access} = {ObjectGen.ObjectName}.{DefaultValueMemberName};");
}
else if (Nullable)
{
sb.AppendLine($"{identifier.Access} = default;");
}
else
{
sb.AppendLine($"{identifier.Access} = {GetDefault(getter: false)};");
}
}
public override void GenerateClear(StructuredStringBuilder sb, Accessor identifier)
{
if (ReadOnly || !IntegrateField)
{
return;
}
// ToDo
// Add internal interface support
if (InternalSetInterface)
{
return;
}
if (!Enabled)
{
return;
}
if (Nullable)
{
sb.AppendLine($"{identifier.Access} = default;");
}
else if (Length.HasValue)
{
sb.AppendLine($"{identifier.Access} = new byte[{Length.Value}];");
}
else
{
sb.AppendLine($"{identifier.Access} = new byte[0];");
}
}
public override void GenerateForEqualsMask(StructuredStringBuilder sb, Accessor accessor, Accessor rhsAccessor, string retAccessor)
{
if (!Nullable)
{
GenerateForEqualsMaskCheck(sb, $"item.{Name}", $"rhs.{Name}", $"ret.{Name}");
}
else
{
sb.AppendLine($"if ({NullableAccessor(getter: true, accessor: accessor)} == {NullableAccessor(getter: true, accessor: rhsAccessor)})");
using (sb.CurlyBrace())
{
sb.AppendLine($"if ({NullableAccessor(getter: true, accessor: accessor)})");
using (sb.CurlyBrace())
{
GenerateForEqualsMaskCheck(sb, $"item.{Name}", $"rhs.{Name}", $"ret.{Name}");
}
sb.AppendLine($"else");
using (sb.CurlyBrace())
{
GenerateForEqualsMask(sb, $"ret.{Name}", true);
}
}
sb.AppendLine($"else");
using (sb.CurlyBrace())
{
GenerateForEqualsMask(sb, $"ret.{Name}", false);
}
}
}
public override void GenerateForEquals(StructuredStringBuilder sb, Accessor accessor, Accessor rhsAccessor, Accessor maskAccessor)
{
sb.AppendLine($"if ({GetTranslationIfAccessor(maskAccessor)})");
using (sb.CurlyBrace())
{
sb.AppendLine($"if (!{accessor.Access}.{nameof(EnumerableExt.SequenceEqualNullable)}({rhsAccessor.Access})) return false;");
}
}
public override void GenerateForEquals(StructuredStringBuilder sb, Accessor accessor, Accessor rhsAccessor, Accessor maskAccessor)
{
sb.AppendLine($"if ({GetTranslationIfAccessor(maskAccessor)})");
using (sb.CurlyBrace())
{
sb.AppendLine($"if (!{accessor.Access}.EqualsWithin({rhsAccessor.Access})) return false;");
}
}
public override void GenerateUnsetNth(StructuredStringBuilder sb, Accessor identifier)
{
if (!ReadOnly)
{
sb.AppendLine($"{identifier}.Unset();");
}
sb.AppendLine("break;");
}
public void GenerateInterfaceMembers(StructuredStringBuilder sb, string member)
{
using (sb.Region("Interface Members"))
{
sb.AppendLine($"[DebuggerBrowsable(DebuggerBrowsableState.Never)]");
sb.AppendLine($"{ListTypeName(getter: true, internalInterface: true)}{NullChar} {ObjectGen.Interface(getter: true, internalInterface: InternalGetInterface)}.{Name} => {member};");
}
}
public override void GenerateSetNth(StructuredStringBuilder sb, Accessor accessor, Accessor rhs, bool internalUse)
{
if (!IntegrateField)
{
return;
}
sb.AppendLine($"{accessor} = {rhs};");
sb.AppendLine($"break;");
}
public void GenerateCopyInRet_Internal(
StructuredStringBuilder sb,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor nodeAccessor,
Accessor itemAccessor,
bool ret,
Accessor errorMaskAccessor,
Accessor translationMaskAccessor)
{
var list = typeGen as ListType;
if (!XmlMod.TryGetTypeGeneration(list.SubTypeGeneration.GetType(), out var subTransl))
{
throw new ArgumentException("Unsupported type generator: " + list.SubTypeGeneration);
}
if (ret)
{
throw new NotImplementedException();
}
MaskGenerationUtility.WrapErrorFieldIndexPush(
sb: sb,
toDo: () =>
{
using (var args = new Function(
sb,
$"if ({TranslatorName}<{list.SubTypeGeneration.TypeName(getter: false, needsCovariance: true)}>.Instance.Parse"))
{
args.AddPassArg($"{XmlTranslationModule.XElementLine.GetParameterName(objGen, Context.Backend)}");
args.Add($"enumer: out var {typeGen.Name}Item");
args.Add($"transl: {subTransl.GetTranslatorInstance(list.SubTypeGeneration, getter: false)}.Parse");
args.Add("errorMask: errorMask");
args.Add($"translationMask: {translationMaskAccessor})");
}
using (sb.CurlyBrace())
{
if (typeGen.Nullable)
{
sb.AppendLine($"{itemAccessor.Access} = {typeGen.Name}Item.ToExtendedList();");
}
else
{
sb.AppendLine($"{itemAccessor.Access}.SetTo({typeGen.Name}Item);");
}
}
sb.AppendLine("else");
using (sb.CurlyBrace())
{
list.GenerateClear(sb, itemAccessor);
}
},
errorMaskAccessor: errorMaskAccessor,
indexAccessor: typeGen.IndexEnumInt);
}
public override void GenerateForEquals(StructuredStringBuilder sb, Accessor accessor, Accessor rhsAccessor, Accessor maskAccessor)
{
sb.AppendLine($"if ({GetTranslationIfAccessor(maskAccessor)})");
using (sb.CurlyBrace())
{
if (SubTypeGeneration is LoquiType subLoq &&
subLoq.TargetObjectGeneration != null)
{
sb.AppendLine($"if (!{accessor.Access}.{(Nullable ? nameof(ICollectionExt.SequenceEqualNullable) : nameof(ICollectionExt.SequenceEqual))}({rhsAccessor.Access}, (l, r) => {subLoq.TargetObjectGeneration.CommonClassSpeccedInstance("l", LoquiInterfaceType.IGetter, CommonGenerics.Class, subLoq.GenericSpecification)}.Equals(l, r, {maskAccessor}?.GetSubCrystal({IndexEnumInt})))) return false;");
}
public override void GenerateClear(StructuredStringBuilder sb, Accessor accessor)
{
if (Nullable)
{
sb.AppendLine($"{accessor} = null;");
}
else
{
sb.AppendLine($"{accessor}.SetAllTo(default);");
}
}
public override void GenerateClear(StructuredStringBuilder sb, Accessor accessorPrefix)
{
if (Nullable)
{
sb.AppendLine($"{accessorPrefix}.Unset();");
}
else
{
sb.AppendLine($"{accessorPrefix}.Clear();");
}
}
public override void GenerateForCopy(StructuredStringBuilder sb, Accessor accessor, Accessor rhs, Accessor copyMaskAccessor, bool protectedMembers, bool deepCopy)
{
if (!AlwaysCopy)
{
sb.AppendLine($"if ({(deepCopy ? GetTranslationIfAccessor(copyMaskAccessor) : SkipCheck(copyMaskAccessor, deepCopy))})");
}
using (sb.CurlyBrace(doIt: !AlwaysCopy))
{
sb.AppendLine($"{accessor.Access} = {rhs};");
}
}
public override void GenerateForEquals(StructuredStringBuilder sb, Accessor accessor, Accessor rhsAccessor, Accessor maskAccessor)
{
if (!IntegrateField)
{
return;
}
sb.AppendLine($"if ({GetTranslationIfAccessor(maskAccessor)})");
using (sb.CurlyBrace())
{
sb.AppendLine($"if ({GenerateEqualsSnippet(accessor, rhsAccessor, negate: true)}) return false;");
}
}
public override void GenerateForTranslationMask(StructuredStringBuilder sb, TypeGeneration field)
{
LoquiType loqui = field as LoquiType;
if (loqui.RefType == LoquiRefType.Direct)
{
sb.AppendLine($"public {loqui.Mask(MaskType.Translation)}? {field.Name};");
}
else
{
sb.AppendLine($"public bool {field.Name};");
}
}
public override void GenerateForErrorMaskCombine(StructuredStringBuilder sb, TypeGeneration field, string accessor, string retAccessor, string rhsAccessor)
{
LoquiType loqui = field as LoquiType;
if (!IsUnknownGeneric(loqui))
{
sb.AppendLine($"{retAccessor} = {accessor}.Combine({rhsAccessor}, (l, r) => l.Combine(r));");
}
else
{
sb.AppendLine($"{retAccessor} = new MaskItem<Exception?, {loqui.Mask(MaskType.Error)}?>(ExceptionExt.Combine({accessor}.Overall, {rhsAccessor}.Overall), Loqui.Internal.LoquiHelper.Combine({accessor}.Specific, {rhsAccessor}.Specific));");
}
}
public override async Task GenerateForClass(StructuredStringBuilder sb)
{
sb.AppendLine($"[DebuggerBrowsable(DebuggerBrowsableState.Never)]");
sb.AppendLine($"private {TypeName(getter: false)}{NullChar} _{Name}{(Nullable ? null : $" = {GetActualItemClass(ctor: true)}")};");
Comments?.Apply(sb, LoquiInterfaceType.Direct);
sb.AppendLine($"public {TypeName(getter: false)}{NullChar} {Name}");
using (sb.CurlyBrace())
{
sb.AppendLine($"get => this._{Name};");
sb.AppendLine($"{((ReadOnly || !Nullable) ? "init" : "set")} => this._{Name} = value;");
}
GenerateInterfaceMembers(sb, $"_{Name}");
}
public static void GenerateExceptionCatcher(StructuredStringBuilder sb, Accessor errorMaskAccessor)
{
sb.AppendLine("catch (Exception ex)");
sb.AppendLine($"when ({errorMaskAccessor} != null)");
using (sb.CurlyBrace())
{
sb.AppendLine($"{errorMaskAccessor}.ReportException(ex);");
}
sb.AppendLine("finally");
using (sb.CurlyBrace())
{
sb.AppendLine("errorMask?.PopIndex();");
}
}
public override void GenerateForTranslate(StructuredStringBuilder sb, TypeGeneration field, string retAccessor, string rhsAccessor, bool indexed)
{
LoquiType loqui = field as LoquiType;
if (IsUnknownGeneric(loqui))
{
sb.AppendLine($"{retAccessor};");
sb.AppendLine($"throw new {nameof(NotImplementedException)}();");
}
else
{
sb.AppendLine($"{retAccessor} = {rhsAccessor} == null ? null : new MaskItem{(indexed ? "Indexed" : null)}<R, {loqui.GenerateMaskString("R")}?>({(indexed ? $"{rhsAccessor}.Index, " : null)}eval({rhsAccessor}.Overall), {rhsAccessor}.Specific?.Translate(eval));");
}
}
protected override async Task GenerateNewSnippet(ObjectGeneration obj, StructuredStringBuilder sb)
{
if (obj.Abstract)
{
sb.AppendLine($"if (!LoquiXmlTranslation.Instance.TryCreate<{obj.Name}>(node, out var ret, errorMask, translationMask))");
using (sb.CurlyBrace())
{
sb.AppendLine($"throw new ArgumentException($\"Unknown {obj.Name} subclass: {{node.Name.LocalName}}\");");
}
}
else
{
sb.AppendLine($"var ret = new {obj.Name}{obj.GetGenericTypes(MaskType.Normal)}();");
}
}
public void AppendWithEmbeddedNewLine()
{
var sb = new StructuredStringBuilder();
sb.AppendLine($"A{Environment.NewLine}B");
Assert.Equal(new string[] { "A", "B" }, sb);
}
public void AppendEmpty()
{
var sb = new StructuredStringBuilder();
sb.AppendLine(String.Empty);
Assert.Equal(new string[] { "" }, sb);
}
public void AppendNull()
{
var sb = new StructuredStringBuilder();
sb.AppendLine(null);
Assert.Equal(new string[] { "" }, sb);
}
public override void GenerateForHash(StructuredStringBuilder sb, Accessor accessor, string hashResultAccessor)
{
if (!IntegrateField)
{
return;
}
if (Nullable)
{
sb.AppendLine($"if ({accessor} is {{}} {Name}Item)");
accessor = $"{Name}Item";
}
using (sb.CurlyBrace(doIt: Nullable))
{
sb.AppendLine($"{hashResultAccessor}.Add({accessor});");
}
}
public override void GenerateCopySetToConverter(StructuredStringBuilder sb)
{
using (sb.IncreaseDepth())
{
sb.AppendLine(".Select(b => new MemorySlice<byte>(b.ToArray()))");
}
}
