private CodeNodeBuilder AddTryConstructor(CodeNodeBuilder builder, INamedTypeSymbol discoveryType, IReadOnlyList <IComponentTypeInfo> components)
{
// Arguments
const string parser = "parser";
const string isSuccess = "isSuccess";
// Create Constructor with try pattern
builder.AddNode($"public {_typeName.TypeName}({discoveryType} {parser}, out bool {isSuccess}) : this()", node => {
for (var i = 0; i < components.Count; ++i)
{
// Initialize every component
node.State($"{Field.Component(i)} = {MemberMethod.InitializeComponent(i)} ( {parser}, out {isSuccess} )");
// If any fails, we bail out
node.If($"!{isSuccess}", node => {
node.State($"{isSuccess} = false");
node.Return();
});
}
// Finally we state that we success
node.State($"{isSuccess} = true");
});
return(builder);
}
private CodeNodeBuilder AddComponentInitializers(CodeNodeBuilder builder, INamedTypeSymbol discoveryType, IReadOnlyList <IComponentTypeInfo> components)
{
for (var i = 0; i < components.Count; ++i)
{
const string parserName = "parser";
const string isSuccess = "isSuccess";
builder.AddNode($"private {components[i].Type} {MemberMethod.InitializeComponent(i)}({discoveryType} {parserName})", node => {
components[i].ProvideInitialize(node, parserName);
});
builder.AddNode($"private {components[i].Type} {MemberMethod.TryInitializeComponent(i)}({discoveryType} {parserName}, out bool {isSuccess})", node => {
components[i].ProvideTryInitialize(node, parserName, isSuccess);
});
}
return(builder);
}
private CodeNodeBuilder AddConstructor(CodeNodeBuilder builder, INamedTypeSymbol discoveryType, IReadOnlyList <IComponentTypeInfo> components)
{
// Create Constructor
const string parser = "parser";
return(builder.AddNode($"public {_typeName.TypeName}({discoveryType} {parser}) : this()", node => {
for (var i = 0; i < components.Count; ++i)
{
node.State($"{Field.Component(i)} = {MemberMethod.InitializeComponent(i)} ( {parser} )");
}
}));
}
public CodeNodeBuilder Build(CodeNodeBuilder builder)
{
const string ReadOnlySpanByte = "ReadOnlySpan<byte>";
const string SpanByte = "Span<byte>";
const string SequenceCursor = "SequenceCursor<byte>";
const string span = "span";
const string cursor = "cursor";
const string readBytes = "readBytes";
const string writtenBytes = "writtenBytes";
const string target = "target";
var accessMod = _accessibility.ToString().ToLower();
var strBuilder = new StringBuilder();
foreach (var arg in PrependArguments)
{
strBuilder.Append(arg);
strBuilder.Append(", ");
}
var prependString = strBuilder.ToString();
// TryDeserialize (ReadOnlySpan<byte>)
builder.AddNode($"{accessMod} {nameof(DeserializeResult)} {MethodNames.TryDeserializeSpan}({prependString}{ReadOnlySpanByte} {span}, out int {readBytes}, out {TargetSymbol} {target})",
node => TryDeserializeSpan(node, span, readBytes, target));
// TryDeserialize (Sequence)
builder.AddNode($"{accessMod} {nameof(DeserializeResult)} {MethodNames.TryDeserializeSequence}({prependString}{SequenceCursor} {cursor}, out {TargetSymbol} {target})",
node => TryDeserializeSequence(node, cursor, target));
// Deserialize (ReadOnlySpan<byte>)
builder.AddNode($"{accessMod} {TargetSymbol} {MethodNames.DeserializeSpan}({prependString}{ReadOnlySpanByte} {span}, out int {readBytes})",
node => DeserializeSpan(node, span, readBytes));
// Deserialize (Sequence)
builder.AddNode($"{accessMod} int {MethodNames.DeserializeSequence}({prependString}{SequenceCursor} {cursor})",
node => DeserializeSequence(node, cursor));
// TrySerialize (ReadOnlySpan<byte>)
builder.AddNode($"{accessMod} bool {MethodNames.TrySerialize}({prependString}in {TargetSymbol} {target}, {SpanByte} {span}, out int {writtenBytes})",
node => TrySerialize(node, target, span, writtenBytes));
// Serialize (ReadOnlySpan<byte>)
builder.AddNode($"{accessMod} int {MethodNames.Serialize}({prependString}in {TargetSymbol} {target}, {SpanByte} {span})",
node => Serialize(node, target, span));
// GetLength
builder.AddNode($"{accessMod} int {MethodNames.GetLength}({prependString}in {TargetSymbol} {target})",
node => GetLength(node, target));
return(builder);
}
public void AddThrowClass(CodeNodeBuilder builder, Accessibility accessbility = Accessibility.Private, bool shouldShowInEditor = false)
{
var accessStr = accessbility.ToString().ToLower();
if (!shouldShowInEditor)
{
builder.AttributeHideEditor();
}
builder.AddNode($"{accessStr} static class {_className} ", node => {
for (var i = 0; i < exceptions.Count; i++)
{
// Note to self : Don't add NoInlining to throw helpers, they actually make performance worse
// Maybe we can refer to these
// https://source.dot.net/#System.Memory/System/ThrowHelper.cs,73669ffe9b1ee4f4
// https://gist.github.com/benaadams/216ed9516dc4e67728fdef1a77574f96
var methodName = ThrowExceptionName(i);
node.State($"public static void {methodName}() => throw Create{methodName}").NewLine();
node.AttributeMethodImpl(MethodImplOptions.NoInlining);
node.State($"public static System.Exception Create{ThrowExceptionName(i)}() => {exceptions[i]}");
}
});
}
