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 static ComposerMethodNames GetDefaultNames(int index)
=> new ComposerMethodNames
{
TryDeserializeSequence = MemberMethod.TryDeserializeState(index),
TryDeserializeSpan = MemberMethod.TryDeserializeState(index),
DeserializeSequence = MemberMethod.TryDeserializeState(index),
DeserializeSpan = MemberMethod.TryDeserializeState(index),
TrySerialize = MemberMethod.TrySerializeState(index),
Serialize = MemberMethod.SerializeState(index),
};
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} )");
}
}));
}
private IReadOnlyList <MethodSignature> GetMethodSignatures(IComponentProvider provider)
{
var boolSymbol = _symbols.GetSymbol <bool>();
var intSymbol = _symbols.GetSymbol <int>();
var memberType = _member.ReturnType !.Symbol;
// Incoming Data type
var discovery = new MethodArg(RefKind.In, provider.DiscoveryType, "parent");
var sourceType = new MethodArg(RefKind.In, _member.ContainingFullType.Symbol, "source");
// Buffers
var readOnlySpan = new MethodArg(_symbols.GetSymbol(typeof(ReadOnlySpan <byte>)), "readOnlySpan");
var span = new MethodArg(_symbols.GetSymbol(typeof(Span <byte>)), "span");
var cursor = new MethodArg(RefKind.Ref, _symbols.GetSymbol(typeof(SequenceCursor <byte>)), "cursor");
// Return Data
var readBytes = new MethodArg(RefKind.Out, intSymbol, "readBytes");
var writtenBytes = new MethodArg(RefKind.Out, intSymbol, "writtenBytes");
var result = new MethodArg(RefKind.Out, memberType, "result");
return(new MethodSignature[] {
MethodSignatureBuilder.CreateConstructor(_typeName, (provider.DiscoveryType, "parser")),
MethodSignatureBuilder.CreateConstructor(_typeName, (provider.DiscoveryType, "parser"), (RefKind.Out, boolSymbol, "isSuccess")),
MethodSignatureBuilder.CreateMethod(_typeName, MemberMethod.TryDeserializeState(0))
.AddArgument(discovery, readOnlySpan, readBytes, result)
.WithReturn <bool>(),
MethodSignatureBuilder.CreateMethod(_typeName, MemberMethod.TryDeserializeState(0))
.AddArgument(discovery, cursor, result)
.WithReturn <bool>(),
MethodSignatureBuilder.CreateMethod(_typeName, MemberMethod.DeserializeState(0))
.AddArgument(discovery, readOnlySpan, result)
.WithReturn(memberType),
MethodSignatureBuilder.CreateMethod(_typeName, MemberMethod.DeserializeState(0))
.AddArgument(discovery, cursor)
.WithReturn(memberType),
MethodSignatureBuilder.CreateMethod(_typeName, MemberMethod.TrySerializeState(0))
.AddArgument(discovery, sourceType, span, writtenBytes)
.WithReturn(boolSymbol),
MethodSignatureBuilder.CreateMethod(_typeName, MemberMethod.SerializeState(0))
.AddArgument(discovery, sourceType, span)
.WithReturn(intSymbol),
MethodSignatureBuilder.CreateMethod(_typeName, MemberMethod.GetLengthState(0))
.AddArgument(discovery, sourceType)
.WithReturn(intSymbol)
});
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);
}
public override void TrySerialize(CodeNodeBuilder node, InArgs <object> target, BufferArgs readOnlySpan, OutArgs <int> outWrittenBytes)
=> node.Return($"{MemberMethod.TrySerializeState(0)} ({parent}, {target}, {readOnlySpan}, out {outWrittenBytes})");
public override void TryDeserializeSpan(CodeNodeBuilder node, BufferArgs readOnlySpan, OutArgs <int> outReadBytes, OutArgs <object> outResult)
=> node.Return($"{MemberMethod.TryDeserializeState(0)}({parent}, {readOnlySpan}, out {outReadBytes}, out {outResult})");
public override void TryDeserializeSequence(CodeNodeBuilder node, BufferArgs refSequenceCursor, OutArgs <object> outResult)
=> node.Return($"{MemberMethod.TryDeserializeState(0)}({parent}, ref {refSequenceCursor}, out {outResult})");
public override void Serialize(CodeNodeBuilder node, InArgs <object> target, BufferArgs readOnlySpan)
=> node.Return($"{MemberMethod.SerializeState(0)}({parent}, {target}, {readOnlySpan})");
public override void GetLength(CodeNodeBuilder node, InArgs <object> target)
=> node.Return($"{MemberMethod.GetLengthState(0)}({parent}, {target} )");
public override void DeserializeSequence(CodeNodeBuilder node, BufferArgs refSequenceCursor)
=> node.AddPlain($"{MemberMethod.TryDeserializeState(0)}({parent}, ref {refSequenceCursor})");
