protected override string GetActualItemClass(bool ctor = false)
{
if (!ctor)
{
return($"{ItemTypeName(getter: false)}[]");
}
if (Nullable)
{
return($"default");
}
else if (FixedSize.HasValue)
{
if (SubTypeGeneration is LoquiType loqui)
{
return($"ArrayExt.Create({FixedSize}, (i) => new {loqui.TargetObjectGeneration.ObjectName}())");
}
else if (SubTypeGeneration.IsNullable ||
SubTypeGeneration.CanBeNullable(getter: false))
{
return($"new {ItemTypeName(getter: false)}[{FixedSize}]");
}
else
{
throw new NotImplementedException();
}
}
else
{
return($"new {ItemTypeName(getter: false)}[0]");
}
}
public override void GenerateForInterface(FileGeneration fg, bool getter, bool internalInterface)
{
if (getter)
{
fg.AppendLine($"IGenderedItemGetter<{SubTypeGeneration.TypeName(getter: true, needsCovariance: true)}{SubTypeGeneration.NullChar}>{(this.Nullable ? "?" : null)} {this.Name} {{ get; }}");
}
else
{
fg.AppendLine($"new IGenderedItem<{SubTypeGeneration.TypeName(getter: false, needsCovariance: true)}{SubTypeGeneration.NullChar}>{(this.Nullable ? "?" : null)} {this.Name} {{ get; set; }}");
}
}
public override void GenerateClear(FileGeneration fg, Accessor accessorPrefix)
{
if (this.Nullable)
{
fg.AppendLine($"{accessorPrefix} = null;");
}
else
{
SubTypeGeneration.GenerateClear(fg, $"{accessorPrefix}.Male");
SubTypeGeneration.GenerateClear(fg, $"{accessorPrefix}.Female");
}
}
public override void GenerateClear(FileGeneration fg, Accessor accessorPrefix)
{
if (this.Nullable)
{
fg.AppendLine($"{accessorPrefix} = null;");
}
else if (SubTypeGeneration is FormLinkType linkType)
{
fg.AppendLine($"{accessorPrefix}.Male = {linkType.DirectTypeName(getter: false)}.Null;");
fg.AppendLine($"{accessorPrefix}.Female = {linkType.DirectTypeName(getter: false)}.Null;");
}
else
{
SubTypeGeneration.GenerateClear(fg, $"{accessorPrefix}.Male");
SubTypeGeneration.GenerateClear(fg, $"{accessorPrefix}.Female");
}
}
public override void GenerateToString(StructuredStringBuilder sb, string name, Accessor accessor, string sbAccessor)
{
sb.AppendLine($"{sbAccessor}.{nameof(StructuredStringBuilder.AppendLine)}(\"{name} =>\");");
sb.AppendLine($"using ({sbAccessor}.Brace())");
using (sb.CurlyBrace())
{
sb.AppendLine($"foreach (var subItem in {accessor.Access})");
using (sb.CurlyBrace())
{
sb.AppendLine($"using ({sbAccessor}.Brace())");
using (sb.CurlyBrace())
{
SubTypeGeneration.GenerateToString(sb, "Item", new Accessor("subItem"), sbAccessor);
}
}
}
}
public override void GenerateForEquals(StructuredStringBuilder sb, Accessor accessor, Accessor rhsAccessor, Accessor maskAccessor)
{
sb.AppendLine($"if ({GetTranslationIfAccessor(maskAccessor)})");
using (sb.CurlyBrace())
{
if (SubTypeGeneration.IsIEquatable)
{
if (Nullable)
{
sb.AppendLine($"if (!{nameof(ObjectExt)}.{nameof(ObjectExt.NullSame)}({accessor}, {rhsAccessor})) return false;");
}
sb.AppendLine($"if (!MemoryExtensions.SequenceEqual<{SubTypeGeneration.TypeName(getter: true)}>({accessor.Access}{(Nullable ? "!.Value" : null)}.Span!, {rhsAccessor.Access}{(Nullable ? "!.Value" : null)}.Span!)) return false;");
}
else
{
sb.AppendLine($"if (!{accessor}.{nameof(EnumerableExt.SequenceEqualNullable)}({rhsAccessor})) return false;");
}
}
}
public override async Task Load(XElement node, bool requireName = true)
{
if (node.Name.LocalName == "RefList")
{
LoadTypeGenerationFromNode(node, requireName);
SubTypeGeneration = ObjectGen.ProtoGen.Gen.GetTypeGeneration <LoquiType>();
SubTypeGeneration.SetObjectGeneration(ObjectGen, setDefaults: false);
await SubTypeGeneration.Load(node, false);
NullableProperty.OnNext(SubTypeGeneration.NullableProperty.Value);
SubTypeGeneration.NullableProperty.OnNext((false, false));
SubTypeGeneration.Name = null;
isLoquiSingle = SubTypeGeneration is LoquiType;
}
else
{
await base.Load(node, requireName);
}
}
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 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 override void GenerateForClass(FileGeneration fg)
{
fg.AppendLine($"public IGenderedItem<{SubTypeGeneration.TypeName(getter: false, needsCovariance: true)}{SubTypeGeneration.NullChar}>{(this.Nullable ? "?" : null)} {this.Name} {{ get; set; }}{(this.Nullable ? null : $" = new GenderedItem<{SubTypeGeneration.TypeName(getter: false, needsCovariance: true)}{(this.ItemNullable ? "?" : null)}>({this.SubTypeGeneration.GetDefault(getter: false)}, {this.SubTypeGeneration.GetDefault(getter: false)});")}");
fg.AppendLine($"IGenderedItemGetter<{SubTypeGeneration.TypeName(getter: true, needsCovariance: true)}{SubTypeGeneration.NullChar}>{(this.Nullable ? "?" : null)} {this.ObjectGen.Interface(getter: true, internalInterface: true)}.{this.Name} => this.{this.Name};");
}
public override string TypeName(bool getter, bool needsCovariance = false)
{
return($"{(getter ? "IGenderedItemGetter" : "IGenderedItem")}<{SubTypeGeneration.TypeName(getter, needsCovariance: true)}{this.SubTypeGeneration.NullChar}>");
}
public override string GetDuplicate(Accessor accessor)
{
return($"{accessor}{NullChar}.{Name}Select(x => {SubTypeGeneration.GetDuplicate("x")}).ToExtendedList()");
}
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);
}
}
