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); } }