public override async Task GenerateInTranslationCreateClass(ObjectGeneration obj, StructuredStringBuilder sb)
{
using (var args = new Function(sb,
$"public static void FillPublic{ModuleNickname}"))
{
args.Add($"{obj.Interface(getter: false, internalInterface: true)} item");
args.Add($"XElement {XElementLine.GetParameterName(obj, Context.Backend)}");
foreach (var item in MainAPI.ReaderAPI.CustomAPI)
{
if (!item.API.TryResolve(obj, TranslationDirection.Reader, Context.Backend, out var line))
{
continue;
}
args.Add(line.Result);
}
args.Add($"ErrorMaskBuilder? errorMask");
args.Add($"{nameof(TranslationCrystal)}? translationMask");
}
using (sb.CurlyBrace())
{
sb.AppendLine("try");
using (sb.CurlyBrace())
{
sb.AppendLine($"foreach (var elem in {XElementLine.GetParameterName(obj, Context.Backend)}.Elements())");
using (sb.CurlyBrace())
{
using (var args = sb.Call(
$"{TranslationCreateClass(obj)}.FillPublicElement{ModuleNickname}"))
{
args.Add("item: item");
args.Add($"{XElementLine.GetParameterName(obj, Context.Backend)}: elem");
args.Add("name: elem.Name.LocalName");
args.Add("errorMask: errorMask");
if (TranslationMaskParameter)
{
args.Add("translationMask: translationMask");
}
foreach (var item in MainAPI.ReaderAPI.CustomAPI)
{
if (!item.API.TryGetPassthrough(obj, TranslationDirection.Reader, Context.Backend, out var passthrough))
{
continue;
}
args.Add(passthrough);
}
}
}
}
sb.AppendLine("catch (Exception ex)");
sb.AppendLine("when (errorMask != null)");
using (sb.CurlyBrace())
{
sb.AppendLine("errorMask.ReportException(ex);");
}
}
sb.AppendLine();
FillPublicElement(obj, sb);
await base.GenerateInTranslationCreateClass(obj, sb);
}
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");
}
}
public override void GenerateWrite(
StructuredStringBuilder sb,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor writerAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor nameAccessor,
Accessor translationMaskAccessor)
{
var eType = typeGen as EnumType;
using (var args = sb.Call(
$"EnumXmlTranslation<{eType.NoNullTypeName}>.Instance.Write"))
{
args.Add($"{XmlTranslationModule.XElementLine.GetParameterName(objGen, Context.Backend)}: {writerAccessor}");
args.Add($"name: {nameAccessor}");
args.Add($"item: {itemAccessor.Access}");
if (typeGen.HasIndex)
{
args.Add($"fieldIndex: (int){typeGen.IndexEnumName}");
}
args.Add($"errorMask: {errorMaskAccessor}");
}
}
private void GenerateCopy(StructuredStringBuilder sb, string accessorPrefix, string rhsAccessorPrefix, bool protectedUse)
{
using (var args = sb.Call(
$"{accessorPrefix}.{GetName(protectedUse)}.SetTo"))
{
args.Add($"(IEnumerable<{ValueTypeGen.TypeName(getter: true)}>){rhsAccessorPrefix}.{GetName(false)}).Select((i) => i.Copy())");
}
}
public override void GenerateSetNth(StructuredStringBuilder sb, Accessor accessor, Accessor rhs, bool internalUse)
{
using (var args = sb.Call(
$"{accessor}.SetTo"))
{
args.Add($"(IEnumerable<{ValueTypeGen.TypeName(getter: true)}>){rhs}");
}
sb.AppendLine("break;");
}
public void GenerateForEqualsMaskCheck(StructuredStringBuilder sb, string accessor, string rhsAccessor, string retAccessor)
{
using (var args = sb.Call(
$"{retAccessor} = EqualsMaskHelper.CacheEqualsHelper"))
{
args.Add($"lhs: {accessor}");
args.Add($"rhs: {rhsAccessor}");
args.Add($"maskGetter: (k, l, r) => l.GetEqualsMask(r, include)");
args.Add("include: include");
}
}
public void GenerateForEqualsMaskCheck(StructuredStringBuilder sb, string accessor, string rhsAccessor, string retAccessor)
{
LoquiType keyLoqui = KeyTypeGen as LoquiType;
LoquiType valLoqui = ValueTypeGen as LoquiType;
if (keyLoqui != null &&
valLoqui != null)
{
throw new NotImplementedException();
}
else if (keyLoqui != null)
{
throw new NotImplementedException();
}
else if (valLoqui != null)
{
using (var args = sb.Call(
$"{retAccessor} = EqualsMaskHelper.DictEqualsHelper"))
{
args.Add($"lhs: {accessor}");
args.Add($"rhs: {rhsAccessor}");
args.Add($"maskGetter: (k, l, r) => l.GetEqualsMask(r, include)");
args.AddPassArg("include");
}
}
else
{
using (var args = sb.Call(
$"{retAccessor} = EqualsMaskHelper.DictEqualsHelper"))
{
args.Add($"lhs: {accessor}");
args.Add($"rhs: {rhsAccessor}");
args.AddPassArg("include");
}
}
}
public override void GenerateCopyIn(
StructuredStringBuilder sb,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor nodeAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor translationMaskAccessor)
{
var loquiGen = typeGen as LoquiType;
if (loquiGen.Singleton)
{
if (loquiGen.SetterInterfaceType == LoquiInterfaceType.IGetter)
{
return;
}
MaskGenerationUtility.WrapErrorFieldIndexPush(
sb,
() =>
{
using (var args = sb.Call(
$"{itemAccessor.Access}.{XmlMod.CopyInFromPrefix}{XmlMod.ModuleNickname}{loquiGen.GetGenericTypes(getter: false, MaskType.Normal)}"))
{
args.Add($"node: {nodeAccessor}");
args.Add($"translationMask: {translationMaskAccessor}");
args.Add($"errorMask: {errorMaskAccessor}");
}
},
errorMaskAccessor: "errorMask",
indexAccessor: $"{typeGen.IndexEnumInt}");
}
else
{
GenerateCopyInRet_Internal(
sb: sb,
objGen: objGen,
typeGen: typeGen,
nodeAccessor: nodeAccessor,
itemAccessor: itemAccessor,
translationMaskAccessor: translationMaskAccessor,
indexAccessor: typeGen.HasIndex ? $"(int){typeGen.IndexEnumName}" : null,
errorMaskAccessor: errorMaskAccessor);
}
}
public override void GenerateForEqualsMask(StructuredStringBuilder sb, Accessor accessor, Accessor rhsAccessor, string retAccessor)
{
string funcStr;
if (SubTypeGeneration is LoquiType loqui)
{
funcStr = $"(loqLhs, loqRhs) => {(loqui.TargetObjectGeneration == null ? "(IMask<bool>)" : null)}loqLhs.{(loqui.TargetObjectGeneration == null ? nameof(IEqualsMask.GetEqualsMask) : "GetEqualsMask")}(loqRhs, include)";
}
else
{
funcStr = $"(l, r) => {SubTypeGeneration.GenerateEqualsSnippet(new Accessor("l"), new Accessor("r"))}";
}
using (var args = sb.Call(
$"ret.{Name} = item.{Name}.Array2dEqualsHelper"))
{
args.Add($"rhs.{Name}");
args.Add(funcStr);
args.Add($"include");
}
}
public override void WrapSet(StructuredStringBuilder sb, Accessor accessor, Action <StructuredStringBuilder> a)
{
if (Nullable)
{
sb.AppendLine($"{accessor} = ");
using (sb.IncreaseDepth())
{
a(sb);
sb.AppendLine($".ShallowClone();");
}
}
else
{
using (var args = sb.Call(
$"{accessor}.SetTo"))
{
args.Add(subFg => a(subFg));
}
}
}
public virtual void WrapSet(StructuredStringBuilder sb, Accessor accessor, Action <StructuredStringBuilder> a)
{
if (Nullable)
{
sb.AppendLine($"{accessor} = ");
using (sb.IncreaseDepth())
{
a(sb);
sb.AppendLine($".ToExtendedList<{SubTypeGeneration.TypeName(getter: false, needsCovariance: true)}>();");
}
}
else
{
using (var args = sb.Call(
$"{accessor}.SetTo"))
{
args.Add(subFg => a(subFg));
}
}
}
public override void GenerateForEqualsMask(StructuredStringBuilder sb, Accessor accessor, Accessor rhsAccessor, string retAccessor)
{
string funcStr;
var loqui = SubTypeGeneration as LoquiType;
if (loqui != null)
{
funcStr = $"(loqLhs, loqRhs) => loqLhs.{(loqui.TargetObjectGeneration == null ? nameof(IEqualsMask.GetEqualsMask) : "GetEqualsMask")}(loqRhs, include)";
}
else
{
funcStr = $"(l, r) => {SubTypeGeneration.GenerateEqualsSnippet(new Accessor("l"), new Accessor("r"))}";
}
using (var args = sb.Call(
$"ret.{Name} = {nameof(EqualsMaskHelper)}.SpanEqualsHelper<{SubTypeGeneration.TypeName(getter: true)}{SubTypeGeneration.NullChar}{(loqui == null ? null : $", {loqui.GetMaskString("bool")}")}>"))
{
args.Add($"item.{Name}");
args.Add($"rhs.{Name}");
args.Add(funcStr);
args.Add($"include");
}
}
public virtual void GenerateWriteToNode(ObjectGeneration obj, StructuredStringBuilder sb)
{
using (var args = new Function(sb,
$"public static void WriteToNode{ModuleNickname}{obj.GetGenericTypes(MaskType.Normal)}"))
{
args.Add($"{obj.Interface(internalInterface: true, getter: true)} item");
args.Add($"XElement {XElementLine.GetParameterName(obj, Context.Backend)}");
args.Add($"ErrorMaskBuilder? errorMask");
args.Add($"{nameof(TranslationCrystal)}? translationMask");
}
using (sb.CurlyBrace())
{
if (obj.HasLoquiBaseObject)
{
using (var args = sb.Call(
$"{TranslationWriteClass(obj.BaseClass)}.WriteToNode{ModuleNickname}"))
{
args.Add($"item: item");
args.Add($"{XElementLine.GetParameterName(obj, Context.Backend)}: {XElementLine.GetParameterName(obj, Context.Backend)}");
args.Add($"errorMask: errorMask");
args.Add($"translationMask: translationMask");
}
}
foreach (var field in obj.IterateFieldIndices())
{
if (!TryGetTypeGeneration(field.Field.GetType(), out var generator))
{
throw new ArgumentException("Unsupported type generator: " + field.Field);
}
if (!generator.ShouldGenerateWrite(field.Field))
{
continue;
}
List <string> conditions = new List <string>();
if (field.Field.Nullable)
{
conditions.Add($"{field.Field.NullableAccessor(getter: true, accessor: Accessor.FromType(field.Field, "item"))}");
}
if (TranslationMaskParameter)
{
conditions.Add(field.Field.GetTranslationIfAccessor("translationMask"));
}
if (conditions.Count > 0)
{
using (var args = sb.If(ands: true))
{
foreach (var item in conditions)
{
args.Add(item);
}
}
}
using (sb.CurlyBrace(doIt: conditions.Count > 0))
{
var maskType = Gen.MaskModule.GetMaskModule(field.Field.GetType()).GetErrorMaskTypeStr(field.Field);
generator.GenerateWrite(
sb: sb,
objGen: obj,
typeGen: field.Field,
writerAccessor: $"{XElementLine.GetParameterName(obj, Context.Backend)}",
itemAccessor: Accessor.FromType(field.Field, "item"),
errorMaskAccessor: $"errorMask",
translationMaskAccessor: "translationMask",
nameAccessor: $"nameof(item.{field.Field.Name})");
}
}
}
sb.AppendLine();
}
public override void GenerateWrite(
StructuredStringBuilder sb,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor writerAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor nameAccessor,
Accessor translationMaskAccessor)
{
var list = typeGen as ListType;
if (!XmlMod.TryGetTypeGeneration(list.SubTypeGeneration.GetType(), out var subTransl))
{
throw new ArgumentException("Unsupported type generator: " + list.SubTypeGeneration);
}
var typeName = list.SubTypeGeneration.TypeName(getter: true, needsCovariance: true);
if (list.SubTypeGeneration is LoquiType loqui)
{
typeName = loqui.TypeNameInternal(getter: true, internalInterface: true);
}
using (var args = sb.Call(
$"{TranslatorName}<{typeName}>.Instance.Write"))
{
args.Add($"{XmlTranslationModule.XElementLine.GetParameterName(objGen, Context.Backend)}: {writerAccessor}");
args.Add($"name: {nameAccessor}");
args.Add($"item: {GetWriteAccessor(itemAccessor)}");
if (typeGen.HasIndex)
{
args.Add($"fieldIndex: (int){typeGen.IndexEnumName}");
}
else
{
throw new NotImplementedException();
}
args.Add($"errorMask: {errorMaskAccessor}");
args.Add($"translationMask: {translationMaskAccessor}?.GetSubCrystal({typeGen.IndexEnumInt})");
args.Add((gen) =>
{
var subTypeName = list.SubTypeGeneration.TypeName(getter: true, needsCovariance: true);
if (list.SubTypeGeneration is LoquiType subLoqui)
{
subTypeName = subLoqui.TypeNameInternal(getter: true, internalInterface: true);
}
gen.AppendLine($"transl: (XElement subNode, {subTypeName} subItem, ErrorMaskBuilder? listSubMask, {nameof(TranslationCrystal)}? listTranslMask) =>");
using (new CurlyBrace(gen))
{
subTransl.GenerateWrite(
sb: gen,
objGen: objGen,
typeGen: list.SubTypeGeneration,
writerAccessor: "subNode",
itemAccessor: new Accessor($"subItem"),
errorMaskAccessor: $"listSubMask",
translationMaskAccessor: "listTranslMask",
nameAccessor: "null");
}
});
ExtraWriteArgs(itemAccessor, typeGen, args);
}
}
public override void GenerateForCopy(
StructuredStringBuilder sb,
Accessor accessor,
Accessor rhs,
Accessor copyMaskAccessor,
bool protectedMembers,
bool deepCopy)
{
void GenerateSet()
{
if (isLoquiSingle)
{
if (deepCopy)
{
LoquiType loqui = SubTypeGeneration as LoquiType;
WrapSet(sb, accessor, (f) =>
{
f.AppendLine(rhs.ToString());
f.AppendLine(".Select(r =>");
using (new CurlyBrace(f)
{
AppendParenthesis = true
})
{
loqui.GenerateTypicalMakeCopy(
f,
retAccessor: $"return ",
rhsAccessor: Accessor.FromType(loqui, "r"),
copyMaskAccessor: copyMaskAccessor,
deepCopy: deepCopy,
doTranslationMask: false);
}
});
}
else
{
LoquiType loqui = SubTypeGeneration as LoquiType;
using (var args = sb.Call(
$"{accessor}.SetTo<{SubTypeGeneration.TypeName(getter: false)}, {SubTypeGeneration.TypeName(getter: false)}>"))
{
args.Add($"items: {rhs}");
args.Add((gen) =>
{
gen.AppendLine("converter: (r) =>");
using (new CurlyBrace(gen))
{
var supportsCopy = loqui.SupportsMask(MaskType.Copy);
var accessorStr = $"copyMask?.{Name}{(supportsCopy ? ".Overall" : string.Empty)}";
gen.AppendLine($"switch ({accessorStr} ?? {nameof(CopyOption)}.{nameof(CopyOption.Reference)})");
using (new CurlyBrace(gen))
{
gen.AppendLine($"case {nameof(CopyOption)}.{nameof(CopyOption.Reference)}:");
using (gen.IncreaseDepth())
{
gen.AppendLine($"return ({loqui.TypeName()})r;");
}
gen.AppendLine($"case {nameof(CopyOption)}.{nameof(CopyOption.MakeCopy)}:");
using (gen.IncreaseDepth())
{
loqui.GenerateTypicalMakeCopy(
gen,
retAccessor: $"return ",
rhsAccessor: new Accessor("r"),
copyMaskAccessor: copyMaskAccessor,
deepCopy: deepCopy,
doTranslationMask: false);
}
gen.AppendLine($"default:");
using (gen.IncreaseDepth())
{
gen.AppendLine($"throw new NotImplementedException($\"Unknown {nameof(CopyOption)} {{{accessorStr}}}. Cannot execute copy.\");");
}
}
}
});
}
}
}
else
{
WrapSet(sb, accessor, (f) =>
{
f.AppendLine($"rhs.{Name}");
SubTypeGeneration.GenerateCopySetToConverter(f);
});
}
}
if (!AlwaysCopy)
{
sb.AppendLine($"if ({(deepCopy ? GetTranslationIfAccessor(copyMaskAccessor) : SkipCheck(copyMaskAccessor, deepCopy))})");
}
using (sb.CurlyBrace(doIt: !AlwaysCopy))
{
MaskGenerationUtility.WrapErrorFieldIndexPush(
sb,
() =>
{
if (Nullable)
{
sb.AppendLine($"if ({NullableAccessor(getter: false, rhs)})");
using (sb.CurlyBrace())
{
GenerateSet();
}
sb.AppendLine("else");
using (sb.CurlyBrace())
{
GenerateClear(sb, accessor);
}
}
else
{
GenerateSet();
}
},
errorMaskAccessor: "errorMask",
indexAccessor: HasIndex?IndexEnumInt: default(Accessor),
doIt: CopyNeedsTryCatch);
}
}
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))
{
if (!KeyIsLoqui && !ValueIsLoqui)
{
using (var args = sb.Call(
$"{accessor}.SetTo"))
{
args.Add($"rhs.{Name}");
}
return;
}
if (deepCopy)
{
if (KeyIsLoqui)
{
throw new NotImplementedException();
}
using (var args = sb.Call(
$"{accessor}.SetTo"))
{
args.Add((gen) =>
{
gen.AppendLine($"rhs.{Name}");
using (gen.IncreaseDepth())
{
gen.AppendLine(".Select((r) =>");
using (new CurlyBrace(gen)
{
AppendParenthesis = true
})
{
(ValueTypeGen as LoquiType).GenerateTypicalMakeCopy(
gen,
retAccessor: $"var value = ",
rhsAccessor: new Accessor("r.Value"),
copyMaskAccessor: copyMaskAccessor,
deepCopy: deepCopy,
doTranslationMask: false);
gen.AppendLine($"return new KeyValuePair<{KeyTypeGen.TypeName(getter: true)}, {ValueTypeGen.TypeName(getter: false)}>(r.Key, value);");
}
}
});
}
return;
}
throw new NotImplementedException();
MaskGenerationUtility.WrapErrorFieldIndexPush(
sb,
() =>
{
if (!KeyIsLoqui && !ValueIsLoqui)
{
using (var args = sb.Call(
$"{accessor}.SetTo"))
{
args.Add($"rhs.{Name}");
}
return;
}
using (var args = sb.Call(
$"{accessor}.SetTo"))
{
args.Add((gen) =>
{
gen.AppendLine($"rhs.{Name}");
using (gen.IncreaseDepth())
{
gen.AppendLine(".Select((r) =>");
using (new CurlyBrace(gen)
{
AppendParenthesis = true
})
{
if (KeyIsLoqui)
{
throw new NotImplementedException();
gen.AppendLine($"{KeyTypeGen.TypeName(getter: false)} key;");
gen.AppendLine($"switch ({copyMaskAccessor}?.Specific.{(BothAreLoqui ? "Key." : string.Empty)}Type ?? {nameof(RefCopyType)}.{nameof(RefCopyType.Reference)})");
using (new CurlyBrace(gen))
{
gen.AppendLine($"case {nameof(RefCopyType)}.{nameof(RefCopyType.Reference)}:");
using (gen.IncreaseDepth())
{
gen.AppendLine($"key = r.Key;");
gen.AppendLine($"break;");
}
gen.AppendLine($"case {nameof(RefCopyType)}.{nameof(RefCopyType.MakeCopy)}:");
using (gen.IncreaseDepth())
{
gen.AppendLine($"key = r.Key.Copy(copyMask: {copyMaskAccessor}?.Specific.{(BothAreLoqui ? "Key." : string.Empty)}Mask);");
gen.AppendLine($"break;");
}
gen.AppendLine($"default:");
using (gen.IncreaseDepth())
{
gen.AppendLine($"throw new NotImplementedException($\"Unknown {nameof(RefCopyType)} {{copyMask?.{Name}.Overall}}. Cannot execute copy.\");");
}
}
}
if (ValueTypeGen is LoquiType valLoqui)
{
gen.AppendLine($"{ValueTypeGen.TypeName(getter: false)} val;");
gen.AppendLine($"switch ({copyMaskAccessor}?.Specific.{(BothAreLoqui ? "Value." : string.Empty)}Type ?? {nameof(RefCopyType)}.{nameof(RefCopyType.Reference)})");
using (new CurlyBrace(gen))
{
gen.AppendLine($"case {nameof(RefCopyType)}.{nameof(RefCopyType.Reference)}:");
using (gen.IncreaseDepth())
{
gen.AppendLine($"val = r.Value;");
gen.AppendLine($"break;");
}
gen.AppendLine($"case {nameof(RefCopyType)}.{nameof(RefCopyType.MakeCopy)}:");
using (gen.IncreaseDepth())
{
valLoqui.GenerateTypicalMakeCopy(
gen,
retAccessor: $"val = ",
rhsAccessor: new Accessor("r.Value"),
copyMaskAccessor: copyMaskAccessor,
deepCopy: deepCopy,
doTranslationMask: false);
gen.AppendLine($"break;");
}
gen.AppendLine($"default:");
using (gen.IncreaseDepth())
{
gen.AppendLine($"throw new NotImplementedException($\"Unknown {nameof(RefCopyType)} {{copyMask?.{Name}.Overall}}. Cannot execute copy.\");");
}
}
}
gen.AppendLine($"return new KeyValuePair<{KeyTypeGen.TypeName(getter: false)}, {ValueTypeGen.TypeName(getter: false)}>({(KeyIsLoqui ? "key" : "r.Key")}, {(ValueIsLoqui ? "val" : "r.Value")});");
}
}
});
}
},
errorMaskAccessor: "errorMask",
indexAccessor: HasIndex?IndexEnumInt: default(Accessor),
doIt: CopyNeedsTryCatch);
}
}
protected override async Task GenerateCopyInSnippet(ObjectGeneration obj, StructuredStringBuilder sb, Accessor accessor)
{
sb.AppendLine("try");
using (sb.CurlyBrace())
{
await PreCreateLoop(obj, sb);
sb.AppendLine($"foreach (var elem in {XElementLine.GetParameterName(obj, Context.Backend)}.Elements())");
using (sb.CurlyBrace())
{
if (obj.IterateFields(includeBaseClass: true).Any(f => f.ReadOnly))
{
using (var args = sb.Call(
$"FillPrivateElement{ModuleNickname}"))
{
args.Add($"item: {accessor}");
args.Add($"{XElementLine.GetParameterName(obj, Context.Backend)}: elem");
args.Add("name: elem.Name.LocalName");
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");
if (TranslationMaskParameter)
{
args.Add("translationMask: translationMask");
}
}
}
using (var args = sb.Call(
$"{TranslationCreateClass(obj)}.FillPublicElement{ModuleNickname}"))
{
args.Add($"item: {accessor}");
args.Add($"{XElementLine.GetParameterName(obj, Context.Backend)}: elem");
args.Add("name: elem.Name.LocalName");
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");
if (TranslationMaskParameter)
{
args.Add("translationMask: translationMask");
}
}
}
await PostCreateLoop(obj, sb);
}
sb.AppendLine("catch (Exception ex)");
sb.AppendLine("when (errorMask != null)");
using (sb.CurlyBrace())
{
sb.AppendLine("errorMask.ReportException(ex);");
}
}
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))
{
MaskGenerationUtility.WrapErrorFieldIndexPush(
sb,
() =>
{
var loqui = ValueTypeGen as LoquiType;
if (Nullable)
{
using (var args = sb.Call(
$"{accessor}.SetTo"))
{
args.Add($"rhs.{Name}");
args.Add((gen) =>
{
gen.AppendLine("(r) =>");
using (new CurlyBrace(gen))
{
gen.AppendLine($"switch (copyMask?.{Name}.Overall ?? {nameof(CopyOption)}.{nameof(CopyOption.Reference)})");
using (new CurlyBrace(gen))
{
gen.AppendLine($"case {nameof(CopyOption)}.{nameof(CopyOption.Reference)}:");
using (gen.IncreaseDepth())
{
gen.AppendLine("return r;");
}
gen.AppendLine($"case {nameof(CopyOption)}.{nameof(CopyOption.MakeCopy)}:");
using (gen.IncreaseDepth())
{
loqui.GenerateTypicalMakeCopy(
gen,
retAccessor: $"return ",
rhsAccessor: new Accessor("r"),
copyMaskAccessor: copyMaskAccessor,
deepCopy: deepCopy,
doTranslationMask: false);
}
gen.AppendLine($"default:");
using (gen.IncreaseDepth())
{
gen.AppendLine($"throw new NotImplementedException($\"Unknown {nameof(CopyOption)} {{copyMask?.{Name}.Overall}}. Cannot execute copy.\");");
}
}
}
});
}
}
else
{
using (var args = sb.Call(
$"{accessor}.SetTo"))
{
args.Add((gen) =>
{
gen.AppendLine($"rhs.{Name}.Items");
using (gen.IncreaseDepth())
{
gen.AppendLine(".Select((r) =>");
using (new CurlyBrace(gen)
{
AppendParenthesis = true
})
{
if (deepCopy)
{
loqui.GenerateTypicalMakeCopy(
gen,
retAccessor: $"return ",
rhsAccessor: new Accessor("r"),
copyMaskAccessor: copyMaskAccessor,
deepCopy: deepCopy,
doTranslationMask: false);
}
else
{
gen.AppendLine($"switch (copyMask?.{Name}.Overall ?? {nameof(CopyOption)}.{nameof(CopyOption.Reference)})");
using (new CurlyBrace(gen))
{
gen.AppendLine($"case {nameof(CopyOption)}.{nameof(CopyOption.Reference)}:");
using (gen.IncreaseDepth())
{
gen.AppendLine("return r;");
}
gen.AppendLine($"case {nameof(CopyOption)}.{nameof(CopyOption.MakeCopy)}:");
using (gen.IncreaseDepth())
{
loqui.GenerateTypicalMakeCopy(
gen,
retAccessor: $"return ",
rhsAccessor: new Accessor("r"),
copyMaskAccessor: copyMaskAccessor,
deepCopy: deepCopy,
doTranslationMask: false);
}
gen.AppendLine($"default:");
using (gen.IncreaseDepth())
{
gen.AppendLine($"throw new NotImplementedException($\"Unknown {nameof(CopyOption)} {{copyMask?.{Name}.Overall}}. Cannot execute copy.\");");
}
}
}
}
}
});
}
}
},
errorMaskAccessor: "errorMask",
indexAccessor: HasIndex?IndexEnumInt: default(Accessor),
doIt: CopyNeedsTryCatch);
}
}
private void GenerateCopyIn_Internal(
StructuredStringBuilder sb,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor nodeAccessor,
Accessor itemAccessor,
bool ret,
Accessor errorMaskAccessor,
Accessor translationMaskAccessor)
{
var dictType = typeGen as IDictType;
TypeGeneration keyTypeGen = dictType.KeyTypeGen;
if (keyTypeGen == null)
{
if (!XmlMod.Gen.TryGetTypeGeneration(dictType.KeyTypeGen.TypeName(getter: false), out keyTypeGen))
{
throw new ArgumentException($"Could not find dictionary key type for {dictType.KeyTypeGen.TypeName(getter: false)}");
}
}
if (!XmlMod.TryGetTypeGeneration(dictType.ValueTypeGen.GetType(), out var valSubTransl))
{
throw new ArgumentException("Unsupported type generator: " + dictType.ValueTypeGen);
}
var valSubMaskStr = valSubTransl.MaskModule.GetMaskModule(dictType.ValueTypeGen.GetType()).GetTranslationMaskTypeStr(dictType.ValueTypeGen);
string prefix;
if (!ret)
{
prefix = null;
}
else
{
prefix = itemAccessor.Access;
}
string funcStr;
switch (dictType.Mode)
{
case DictMode.KeyValue:
funcStr = $"{prefix}DictXmlTranslation<{dictType.KeyTypeGen.TypeName(getter: false)}, {dictType.ValueTypeGen.TypeName(getter: false)}>.Instance.Parse{(ret ? null : "Into")}";
break;
case DictMode.KeyedValue:
funcStr = $"{prefix}KeyedDictXmlTranslation<{dictType.KeyTypeGen.TypeName(getter: false)}, {dictType.ValueTypeGen.TypeName(getter: false)}>.Instance.Parse{(ret ? null : "Into")}";
break;
default:
throw new NotImplementedException();
}
using (var args = sb.Call(funcStr))
{
args.AddPassArg($"{XmlTranslationModule.XElementLine.GetParameterName(objGen, Context.Backend)}");
if (!ret)
{
args.Add($"item: {itemAccessor.Access}");
}
if (typeGen.HasIndex)
{
args.Add($"fieldIndex: (int){typeGen.IndexEnumName}");
args.Add($"errorMask: {errorMaskAccessor}");
}
else
{
throw new NotImplementedException();
}
args.Add($"translationMask: {translationMaskAccessor}");
switch (dictType.Mode)
{
case DictMode.KeyValue:
if (!XmlMod.TryGetTypeGeneration(dictType.KeyTypeGen.GetType(), out var keySubTransl))
{
throw new ArgumentException("Unsupported type generator: " + dictType.KeyTypeGen);
}
args.Add($"keyTransl: {keySubTransl.GetTranslatorInstance(dictType.KeyTypeGen, getter: false)}.Parse");
args.Add($"valTransl: {valSubTransl.GetTranslatorInstance(dictType.ValueTypeGen, getter: false)}.Parse");
break;
case DictMode.KeyedValue:
args.Add($"valTransl: {valSubTransl.GetTranslatorInstance(dictType.ValueTypeGen, getter: false)}.Parse");
break;
default:
throw new ArgumentException();
}
}
}
public override void GenerateWrite(
StructuredStringBuilder sb,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor writerAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor nameAccessor,
Accessor translationMaskAccessor)
{
var dictType = typeGen as DictType;
if (!XmlMod.TryGetTypeGeneration(dictType.ValueTypeGen.GetType(), out var valTransl))
{
throw new ArgumentException("Unsupported type generator: " + dictType.ValueTypeGen);
}
switch (dictType.Mode)
{
case DictMode.KeyValue:
if (!XmlMod.TryGetTypeGeneration(dictType.KeyTypeGen.GetType(), out var keyTransl))
{
throw new ArgumentException("Unsupported type generator: " + dictType.KeyTypeGen);
}
using (var args = sb.Call(
$"DictXmlTranslation<{dictType.KeyTypeGen.TypeName(getter: true)}, {dictType.ValueTypeGen.TypeName(getter: true)}>.Instance.Write"))
{
args.Add($"node: {writerAccessor}");
args.Add($"name: {nameAccessor}");
args.Add($"items: {itemAccessor.Access}");
if (typeGen.HasIndex)
{
args.Add($"fieldIndex: (int){typeGen.IndexEnumName}");
args.Add($"errorMask: {errorMaskAccessor}");
}
else
{
throw new NotImplementedException();
}
args.Add($"translationMask: {translationMaskAccessor}");
args.Add((gen) =>
{
gen.AppendLine($"keyTransl: (XElement subNode, {dictType.KeyTypeGen.TypeName(getter: true)} subItem, ErrorMaskBuilder? dictSubMask, {nameof(TranslationCrystal)}? dictSubTranslMask) =>");
using (new CurlyBrace(gen))
{
keyTransl.GenerateWrite(
sb: gen,
objGen: objGen,
typeGen: dictType.KeyTypeGen,
writerAccessor: "subNode",
itemAccessor: $"subItem",
errorMaskAccessor: $"dictSubMask",
translationMaskAccessor: "dictSubTranslMask",
nameAccessor: "\"Key\"");
}
});
args.Add((gen) =>
{
gen.AppendLine($"valTransl: (XElement subNode, {dictType.ValueTypeGen.TypeName(getter: true)} subItem, ErrorMaskBuilder? dictSubMask, {nameof(TranslationCrystal)}? dictSubTranslMask) =>");
using (new CurlyBrace(gen))
{
valTransl.GenerateWrite(
sb: gen,
objGen: objGen,
typeGen: dictType.ValueTypeGen,
writerAccessor: "subNode",
itemAccessor: $"subItem",
errorMaskAccessor: $"dictSubMask",
translationMaskAccessor: "dictSubTranslMask",
nameAccessor: "\"Value\"");
}
});
}
break;
case DictMode.KeyedValue:
MaskGenerationUtility.WrapErrorFieldIndexPush(
sb: sb,
toDo: () =>
{
using (var args = sb.Call(
$"KeyedDictXmlTranslation<{dictType.KeyTypeGen.TypeName(getter: true)}, {dictType.ValueTypeGen.TypeName(getter: true)}>.Instance.Write"))
{
args.Add($"{XmlTranslationModule.XElementLine.GetParameterName(objGen, Context.Backend)}: {writerAccessor}");
args.Add($"name: {nameAccessor}");
args.Add($"items: {itemAccessor.Access}.Items");
args.Add($"translationMask: {translationMaskAccessor}");
args.Add("errorMask: errorMask");
args.Add((gen) =>
{
gen.AppendLine($"valTransl: (XElement subNode, {dictType.ValueTypeGen.TypeName(getter: true)} subItem, ErrorMaskBuilder? dictSubMask, {nameof(TranslationCrystal)}? dictTranslMask) =>");
using (new CurlyBrace(gen))
{
valTransl.GenerateWrite(
sb: gen,
objGen: objGen,
typeGen: dictType.ValueTypeGen,
writerAccessor: "subNode",
itemAccessor: new Accessor($"subItem"),
errorMaskAccessor: $"dictSubMask",
translationMaskAccessor: "dictTranslMask",
nameAccessor: "null");
}
});
}
},
errorMaskAccessor: errorMaskAccessor,
indexAccessor: typeGen.IndexEnumInt);
break;
default:
throw new NotImplementedException();
}
}
protected virtual void FillPublicElement(ObjectGeneration obj, StructuredStringBuilder sb)
{
using (var args = new Function(sb,
$"public static void FillPublicElement{ModuleNickname}"))
{
args.Add($"{obj.Interface(getter: false)} item");
args.Add($"XElement {XElementLine.GetParameterName(obj, Context.Backend)}");
args.Add("string name");
args.Add($"ErrorMaskBuilder? errorMask");
args.Add($"{nameof(TranslationCrystal)}? translationMask");
}
using (sb.CurlyBrace())
{
sb.AppendLine("switch (name)");
using (sb.CurlyBrace())
{
foreach (var field in obj.IterateFields())
{
if (field.Derivative)
{
continue;
}
if (field.ReadOnly)
{
continue;
}
if (!TryGetTypeGeneration(field.GetType(), out var generator))
{
throw new ArgumentException("Unsupported type generator: " + field);
}
sb.AppendLine($"case \"{field.Name}\":");
using (sb.IncreaseDepth())
{
if (generator.ShouldGenerateCopyIn(field))
{
List <string> conditions = new List <string>();
if (TranslationMaskParameter)
{
conditions.Add(field.GetTranslationIfAccessor("translationMask"));
}
if (conditions.Count > 0)
{
using (var args = sb.If(ands: true))
{
foreach (var item in conditions)
{
args.Add(item);
}
}
}
using (sb.CurlyBrace(doIt: conditions.Count > 0))
{
generator.GenerateCopyIn(
sb: sb,
objGen: obj,
typeGen: field,
nodeAccessor: XElementLine.GetParameterName(obj, Context.Backend).Result,
itemAccessor: Accessor.FromType(field, "item"),
translationMaskAccessor: "translationMask",
errorMaskAccessor: $"errorMask");
}
}
sb.AppendLine("break;");
}
}
sb.AppendLine("default:");
using (sb.IncreaseDepth())
{
if (obj.HasLoquiBaseObject)
{
using (var args = sb.Call(
$"{obj.BaseClass.CommonClassName(LoquiInterfaceType.ISetter)}.FillPublicElement{ModuleNickname}{obj.GetBaseMask_GenericTypes(MaskType.Error)}"))
{
args.Add("item: item");
args.Add($"{XElementLine.GetParameterName(obj, Context.Backend)}: {XElementLine.GetParameterName(obj, Context.Backend)}");
args.Add("name: name");
args.Add("errorMask: errorMask");
if (TranslationMaskParameter)
{
args.Add($"translationMask: translationMask");
}
}
}
sb.AppendLine("break;");
}
}
}
sb.AppendLine();
}
