public override void GenerateToString(StructuredStringBuilder sb, string name, Accessor accessor, string sbAccessor)
{
sb.AppendLine($"sb.{nameof(StructuredStringBuilder.AppendLine)}(\"{name} =>\");");
sb.AppendLine($"using (sb.Brace())");
using (sb.CurlyBrace())
{
sb.AppendLine($"foreach (var subItem in {accessor.Access})");
using (sb.CurlyBrace())
{
sb.AppendLine($"using ({sbAccessor}.Brace())");
using (sb.CurlyBrace())
{
KeyTypeGen.GenerateToString(sb, "Key", new Accessor("subItem.Key"), sbAccessor);
ValueTypeGen.GenerateToString(sb, "Value", new Accessor("subItem.Value"), sbAccessor);
}
}
}
}
public override void GenerateForHash(StructuredStringBuilder sb, Accessor accessor, string hashResultAccessor)
{
if (!IntegrateField)
{
return;
}
var doIf = Nullable && CanBeNullable(getter: true);
if (doIf)
{
sb.AppendLine($"if ({accessor} is {{}} {Name}item)");
accessor = $"{Name}item";
}
using (sb.CurlyBrace(doIt: doIf))
{
sb.AppendLine($"{hashResultAccessor}.Add({accessor});");
}
}
public void TwoParameters()
{
var sb = new StructuredStringBuilder();
using (var commentWrapper = new Comment(sb))
{
commentWrapper.AddParameter("name", "The name of the thing");
commentWrapper.AddParameter("thing", "The thing of the thing");
}
var expected = new string[]
{
"/// <param name=\"name\">The name of the thing</param>",
"/// <param name=\"thing\">The thing of the thing</param>",
};
Assert.Equal(expected, sb);
}
public void OneSummaryLine()
{
var sb = new StructuredStringBuilder();
using (var commentWrapper = new Comment(sb))
{
commentWrapper.Summary.AppendLine("An awesome summary.");
}
var expected = new string[]
{
"/// <summary>",
"/// An awesome summary.",
"/// </summary>",
};
Assert.Equal(expected, sb);
}
public override void GenerateSetNth(StructuredStringBuilder sb, Accessor accessor, Accessor rhs, bool internalUse)
{
sb.AppendLine($"{accessor}.SetTo(");
using (sb.IncreaseDepth())
{
sb.AppendLine($"({rhs}).Select(");
using (sb.IncreaseDepth())
{
sb.AppendLine($"(i) => new KeyValuePair<{KeyTypeGen.TypeName(getter: false)}, {ValueTypeGen.TypeName(getter: false)}>(");
using (sb.IncreaseDepth())
{
sb.AppendLine($"i.Key{(KeyIsLoqui ? ".Copy()" : string.Empty) },");
sb.AppendLine($"i.Value{(ValueIsLoqui ? ".Copy()" : string.Empty)})),");
}
}
}
sb.AppendLine($"break;");
}
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 void GenerateCopyIn(
StructuredStringBuilder sb,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor nodeAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor translationMaskAccessor)
{
GenerateCopyIn_Internal(
sb: sb,
objGen: objGen,
typeGen: typeGen,
nodeAccessor: nodeAccessor,
itemAccessor: itemAccessor,
ret: false,
translationMaskAccessor: translationMaskAccessor,
errorMaskAccessor: errorMaskAccessor);
}
public Namespace(StructuredStringBuilder sb, string str, bool fileScoped = true)
{
_fileScoped = fileScoped;
_sb = sb;
_doThings = !string.IsNullOrWhiteSpace(str);
if (_doThings)
{
sb.AppendLine($"namespace {str}{(_fileScoped ? ";" : null)}");
if (_fileScoped)
{
_sb.AppendLine();
}
else
{
sb.AppendLine("{");
sb.Depth++;
}
}
}
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 async Task GenerateForClass(StructuredStringBuilder sb)
{
sb.AppendLine($"[DebuggerBrowsable(DebuggerBrowsableState.Never)]");
sb.AppendLine($"private readonly {DictInterface(getter: false)} _{Name} = new {GetActualItemClass(getter: false)};");
Comments?.Apply(sb, LoquiInterfaceType.Direct);
sb.AppendLine($"public {DictInterface(getter: false)} {Name} => _{Name};");
var member = $"_{Name}";
using (sb.Region("Interface Members"))
{
if (!ReadOnly)
{
sb.AppendLine($"[DebuggerBrowsable(DebuggerBrowsableState.Never)]");
sb.AppendLine($"{DictInterface(getter: false)} {ObjectGen.Interface(internalInterface: false)}.{Name} => {member};");
}
sb.AppendLine($"[DebuggerBrowsable(DebuggerBrowsableState.Never)]");
sb.AppendLine($"{DictInterface(getter: true)} {ObjectGen.Interface(getter: true, internalInterface: false)}.{Name} => {member};");
}
}
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 void Apply(StructuredStringBuilder sb, LoquiInterfaceType type)
{
switch (type)
{
case LoquiInterfaceType.Direct:
Comments.Apply(sb);
break;
case LoquiInterfaceType.ISetter:
(SetterInterface ?? Comments).Apply(sb);
break;
case LoquiInterfaceType.IGetter:
(GetterInterface ?? Comments).Apply(sb);
break;
default:
break;
}
}
public void MultiLineReturns()
{
var sb = new StructuredStringBuilder();
using (var commentWrapper = new Comment(sb))
{
commentWrapper.Return.AppendLine("Awesomeness,");
commentWrapper.Return.AppendLine("sheer awesomeness!");
}
var expected = new string[]
{
"/// <returns>",
"/// Awesomeness,",
"/// sheer awesomeness!",
"/// </returns>",
};
Assert.Equal(expected, sb);
}
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,
() =>
{
if (Nullable)
{
sb.AppendLine($"if(rhs.{Name} is {{}} {Name}rhs)");
using (sb.CurlyBrace())
{
sb.AppendLine($"{accessor.Access} = {Name}rhs{(deepCopy ? null : ".Value")}.ToArray();");
}
sb.AppendLine("else");
using (sb.CurlyBrace())
{
sb.AppendLine($"{accessor.Access} = default;");
}
}
else
{
sb.AppendLine($"{accessor.Access} = {rhs}.ToArray();");
}
},
errorMaskAccessor: "errorMask",
indexAccessor: HasIndex?IndexEnumInt: default(Accessor),
doIt: CopyNeedsTryCatch);
}
}
public override void GenerateClear(StructuredStringBuilder sb, Accessor identifier)
{
if (ReadOnly || !IntegrateField)
{
return;
}
// ToDo
// Add internal interface support
if (InternalSetInterface)
{
return;
}
if (Nullable)
{
sb.AppendLine($"{identifier.Access} = default;");
}
else
{
throw new NotImplementedException();
}
}
public override void GenerateForAny(StructuredStringBuilder sb, TypeGeneration field, Accessor accessor, bool nullCheck, bool indexed)
{
LoquiType loqui = field as LoquiType;
if (nullCheck)
{
sb.AppendLine($"if ({field.Name} != null)");
}
using (sb.CurlyBrace(doIt: nullCheck))
{
sb.AppendLine($"if (eval({accessor.Access}.Overall)) return true;");
if (!IsUnknownGeneric(loqui))
{
sb.AppendLine($"if ({accessor.Access}.Specific != null && {accessor.Access}.Specific.Any(eval)) return true;");
}
else
{
sb.AppendLine($"if (({accessor.Access}.Specific?.Any(eval) ?? false)) return true;");
}
}
}
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 static void WrapErrorFieldIndexPush(
StructuredStringBuilder sb,
Action toDo,
Accessor errorMaskAccessor,
Accessor indexAccessor,
bool doIt = true)
{
if (!doIt)
{
toDo();
return;
}
if (!string.IsNullOrWhiteSpace(indexAccessor.Access))
{
sb.AppendLine($"{errorMaskAccessor}?.PushIndex({indexAccessor});");
}
sb.AppendLine("try");
using (sb.CurlyBrace())
{
toDo();
}
GenerateExceptionCatcher(sb, errorMaskAccessor);
}
public void MultiLineParameter()
{
var sb = new StructuredStringBuilder();
using (var commentWrapper = new Comment(sb))
{
var description = new StructuredStringBuilder();
description.AppendLine("The name of");
description.AppendLine("the thing");
commentWrapper.Parameters["name"] = description;
}
var expected = new string[]
{
"/// <param name=\"name\">",
"/// The name of",
"/// the thing",
"/// </param>",
};
Assert.Equal(expected, sb);
}
public override void GenerateWrite(
StructuredStringBuilder sb,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor writerAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor nameAccessor,
Accessor translationMaskAccessor)
{
using (var args = sb.Call(
$"{TypeName(typeGen)}XmlTranslation.Instance.Write"))
{
args.Add($"{XmlTranslationModule.XElementLine.GetParameterName(objGen, Context.Backend)}: {writerAccessor}");
args.Add($"name: {nameAccessor}");
args.Add($"item: {ItemWriteAccess(typeGen, itemAccessor)}");
if (typeGen.HasIndex)
{
args.Add($"fieldIndex: (int){typeGen.IndexEnumName}");
}
args.Add($"errorMask: {errorMaskAccessor}");
}
}
public override void GenerateCopyIn(
StructuredStringBuilder sb,
ObjectGeneration objGen,
TypeGeneration typeGen,
Accessor nodeAccessor,
Accessor itemAccessor,
Accessor errorMaskAccessor,
Accessor translationMaskAccessor)
{
var byteArray = typeGen as ByteArrayType;
List <string> extraArgs = new List <string>();
extraArgs.Add($"{XmlTranslationModule.XElementLine.GetParameterName(objGen, Context.Backend)}: {nodeAccessor}");
if (byteArray.Length != null)
{
extraArgs.Add($"fallbackLength: {byteArray.Length}");
}
else if (!byteArray.Nullable)
{
extraArgs.Add($"fallbackLength: 0");
}
WrapParseCall(
new TranslationWrapParseArgs()
{
FG = sb,
TypeGen = typeGen,
TranslatorLine = $"{TypeName(typeGen)}XmlTranslation.Instance",
MaskAccessor = errorMaskAccessor,
ItemAccessor = itemAccessor,
TranslationMaskAccessor = null,
IndexAccessor = new Accessor(typeGen.IndexEnumInt),
ExtraArgs = extraArgs.ToArray()
});
}
public void WriteOnDispose()
{
var sb = new StructuredStringBuilder();
using (var commentWrapper = new Comment(sb))
{
commentWrapper.Return.AppendLine("Awesomeness,");
var description = new StructuredStringBuilder();
description.AppendLine("The name of");
description.AppendLine("the thing");
commentWrapper.Parameters["name"] = description;
commentWrapper.Summary.AppendLine("An awesome summary.");
commentWrapper.Return.AppendLine("sheer awesomeness!");
commentWrapper.AddParameter("thing", "The thing of the thing");
}
var expected = new string[]
{
"/// <summary>",
"/// An awesome summary.",
"/// </summary>",
"/// <param name=\"name\">",
"/// The name of",
"/// the thing",
"/// </param>",
"/// <param name=\"thing\">The thing of the thing</param>",
"/// <returns>",
"/// Awesomeness,",
"/// sheer awesomeness!",
"/// </returns>",
};
Assert.Equal(expected, sb);
}
public override void GenerateForInterface(StructuredStringBuilder sb, bool getter, bool internalInterface)
{
if (getter)
{
if (!ApplicableInterfaceField(getter, internalInterface))
{
return;
}
Comments?.Apply(sb, getter ? LoquiInterfaceType.IGetter : LoquiInterfaceType.ISetter);
sb.AppendLine($"{TypeName(getter: true)}{(Nullable && CanBeNullable(getter) ? "?" : null)} {Name} {{ get; }}");
if (Nullable && !CanBeNullable(getter))
{
sb.AppendLine($"bool {Name}_IsSet {{ get; }}");
}
}
else
{
if (!ApplicableInterfaceField(getter, internalInterface))
{
return;
}
Comments?.Apply(sb, getter ? LoquiInterfaceType.IGetter : LoquiInterfaceType.ISetter);
sb.AppendLine($"new {TypeName(getter: false)}{(Nullable && CanBeNullable(getter) ? "?" : null)} {Name} {{ get; set; }}");
if (!CanBeNullable(false))
{
if (Nullable)
{
sb.AppendLine($"new bool {NullableAccessor(getter: false, accessor: new Accessor(Name))} {{ get; set; }}");
sb.AppendLine($"void {Name}_Set({TypeName(getter: false)} value, bool hasBeenSet = true);");
sb.AppendLine($"void {Name}_Unset();");
sb.AppendLine();
}
}
}
}
public override void GenerateForCopyMask(StructuredStringBuilder sb, TypeGeneration field)
{
LoquiType loqui = field as LoquiType;
if (loqui.RefType == LoquiRefType.Direct)
{
if (loqui.Singleton)
{
if (loqui.SetterInterfaceType == LoquiInterfaceType.IGetter)
{
return;
}
sb.AppendLine($"public MaskItem<bool, {loqui.Mask(MaskType.Copy)}> {field.Name};");
}
else
{
sb.AppendLine($"public MaskItem<{nameof(CopyOption)}, {loqui.Mask(MaskType.Copy)}> {field.Name};");
}
}
else
{
sb.AppendLine($"public {nameof(CopyOption)} {field.Name};");
}
}
public override void GenerateForCopyMaskCtor(StructuredStringBuilder sb, TypeGeneration field, string basicValueStr, string deepCopyStr)
{
LoquiType loqui = field as LoquiType;
if (loqui.RefType == LoquiRefType.Direct)
{
if (loqui.Singleton)
{
if (loqui.SetterInterfaceType == LoquiInterfaceType.IGetter)
{
return;
}
sb.AppendLine($"this.{field.Name} = new MaskItem<bool, {loqui.Mask(MaskType.Copy)}>({basicValueStr}, default);");
}
else
{
sb.AppendLine($"this.{field.Name} = new MaskItem<{nameof(CopyOption)}, {loqui.Mask(MaskType.Copy)}>({deepCopyStr}, default);");
}
}
else
{
sb.AppendLine($"this.{field.Name} = {deepCopyStr};");
}
}
public override async Task GenerateForClass(StructuredStringBuilder sb)
{
sb.AppendLine($"private readonly Dictionary<{TypeTuple(getter: false)}> _{Name} = new Dictionary<{TypeTuple(getter: false)}>();");
Comments?.Apply(sb, LoquiInterfaceType.Direct);
sb.AppendLine($"public IDictionary<{TypeTuple(getter: false)}> {Name} => _{Name};");
var member = "_" + Name;
using (new Region(sb, "Interface Members"))
{
if (!ReadOnly)
{
sb.AppendLine($"IDictionary{(ReadOnly ? "Getter" : string.Empty)}<{TypeTuple(getter: false)}> {ObjectGen.Interface()}.{Name} => {member};");
}
if (ValueIsLoqui)
{
sb.AppendLine($"IReadOnlyDictionary<{TypeTuple(getter: true)}> {ObjectGen.Interface(getter: true)}.{Name} => {member}.Covariant<{TypeTuple(getter: false)}, {ValueTypeGen.TypeName(getter: true)}>();");
}
else
{
sb.AppendLine($"IReadOnlyDictionary<{TypeTuple(getter: true)}> {ObjectGen.Interface(getter: true)}.{Name} => {member};");
}
}
}
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");
}
}
}
protected override async Task GenerateCtor(StructuredStringBuilder sb)
{
if (BasicCtorPermission == CtorPermissionLevel.noGeneration)
{
return;
}
if (BasicCtorPermission == CtorPermissionLevel.@public)
{
sb.AppendLine($"public {Name}(");
List <string> lines = new List <string>();
foreach (var field in IterateFields())
{
lines.Add($"{field.TypeName(getter: false)} {field.Name} = default({field.TypeName(getter: false)})");
}
for (int i = 0; i < lines.Count; i++)
{
using (sb.IncreaseDepth())
{
using (sb.Line())
{
sb.Append(lines[i]);
if (i != lines.Count - 1)
{
sb.Append(",");
}
else
{
sb.Append(")");
}
}
}
}
using (sb.CurlyBrace())
{
foreach (var field in IterateFields())
{
sb.AppendLine($"this.{field.Name} = {field.Name};");
}
foreach (var mod in gen.GenerationModules)
{
await mod.GenerateInCtor(this, sb);
}
sb.AppendLine("CustomCtor();");
}
sb.AppendLine();
}
sb.AppendLine($"{BasicCtorPermission.ToStringFast_Enum_Only()} {Name}({Interface(getter: true)} rhs)");
using (sb.CurlyBrace())
{
foreach (var field in IterateFields())
{
sb.AppendLine($"this.{field.Name} = {field.GenerateACopy("rhs." + field.Name)};");
}
}
sb.AppendLine();
sb.AppendLine("partial void CustomCtor();");
sb.AppendLine();
}
public void GenerateCopyCtor(StructuredStringBuilder sb, string accessor, string rhs)
{
}
