public override void GenerateCopyIn(FileGeneration fg, ObjectGeneration objGen, TypeGeneration typeGen, Accessor nodeAccessor, Accessor itemAccessor, Accessor errorMaskAccessor, Accessor translationMaskAccessor)
{
GenderedType gendered = typeGen as GenderedType;
var gen = this.XmlMod.GetTypeGeneration(gendered.SubTypeGeneration.GetType());
MaskGenerationUtility.WrapErrorFieldIndexPush(
fg,
() =>
{
using (var args = new ArgsWrapper(fg,
$"{itemAccessor} = new {typeGen.TypeName(getter: false)}"))
{
args.Add(subFg =>
{
gen.GenerateCopyIn(subFg, objGen, gendered.SubTypeGeneration, nodeAccessor, Accessor.ConstructorParam($"male"), errorMaskAccessor, translationMaskAccessor: null);
});
args.Add(subFg =>
{
gen.GenerateCopyIn(subFg, objGen, gendered.SubTypeGeneration, nodeAccessor, Accessor.ConstructorParam($"female"), errorMaskAccessor, translationMaskAccessor: null);
});
}
},
errorMaskAccessor,
typeGen.HasIndex ? typeGen.IndexEnumInt : default(Accessor));
}
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 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 GenerateForCopy(
StructuredStringBuilder sb,
Accessor accessor,
Accessor rhs,
Accessor copyMaskAccessor,
bool protectedMembers,
bool deepCopy)
{
if (!IntegrateField)
{
return;
}
if (!AlwaysCopy)
{
sb.AppendLine($"if ({(deepCopy ? GetTranslationIfAccessor(copyMaskAccessor) : SkipCheck(copyMaskAccessor, deepCopy))})");
}
using (sb.CurlyBrace(doIt: !AlwaysCopy))
{
MaskGenerationUtility.WrapErrorFieldIndexPush(
sb,
() =>
{
if (Nullable)
{
sb.AppendLine($"if ({rhs} is {{}} item{Name})");
using (sb.CurlyBrace())
{
sb.AppendLine($"{accessor.Access} = item{Name};");
}
sb.AppendLine("else");
using (sb.CurlyBrace())
{
sb.AppendLine($"{accessor.Access} = default;");
}
}
else
{
sb.AppendLine($"{accessor.Access} = {rhs};");
}
},
errorMaskAccessor: "errorMask",
indexAccessor: HasIndex?IndexEnumInt: default(Accessor),
doIt: CopyNeedsTryCatch);
}
}
public override void GenerateCopyIn(
FileGeneration fg,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor frameAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor translationMaskAccessor)
{
FormLinkType linkType = typeGen as FormLinkType;
MaskGenerationUtility.WrapErrorFieldIndexPush(fg,
() =>
{
if (itemAccessor.IsAssignment)
{
using (var args = new ArgsWrapper(fg,
$"{itemAccessor} = {(linkType.FormIDType == FormLinkType.FormIDTypeEnum.Normal ? "FormKey" : "RecordType")}XmlTranslation.Instance.Parse"))
{
args.AddPassArg("node");
args.AddPassArg("errorMask");
}
}
else
{
using (var args = new FunctionWrapper(fg,
itemAccessor.Assign($"new {linkType.DirectTypeName(getter: false)}")))
{
args.Add(subFg =>
{
using (var subArgs = new FunctionWrapper(subFg,
$"FormKeyXmlTranslation.Instance.Parse"))
{
subArgs.AddPassArg("node");
subArgs.AddPassArg("errorMask");
}
});
}
}
},
indexAccessor: typeGen.HasIndex?typeGen.IndexEnumInt: null,
errorMaskAccessor: errorMaskAccessor,
doIt: typeGen.HasIndex);
}
public static void WrapParseCall(TranslationWrapParseArgs param)
{
MaskGenerationUtility.WrapErrorFieldIndexPush(param.FG,
() =>
{
Call args;
bool parseInto = IsParseInto(param.TypeGen, param.ItemAccessor);
bool doIf = !parseInto && param.UnsetCall != null;
if (param.AsyncMode == AsyncMode.Off)
{
string prefix = null;
if (doIf)
{
prefix = $"if (";
}
else if (!parseInto)
{
prefix = $"{param.ItemAccessor.Access}{param.ItemAccessor.AssignmentOperator}";
}
args = param.FG.Call(
$"{prefix}{param.TranslatorLine}.{(param.FunctionNameOverride == null ? $"Parse{(parseInto ? "Into" : null)}" : param.FunctionNameOverride)}{(param.Generic == null ? null : $"<{param.Generic}>")}",
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();
}
}
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);
}
}
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))
{
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);
}
}
