public MemberComposerSource(MemberMetaInfo layoutMember, GeneratingTypeName typeName,
IEnumerable <IConditionResolverProvider> conditions,
IEnumerable <IMemberDataFormatterProvider> formatters,
ITypeSymbolProvider symbolProvider)
{
if (_member.ReturnType is null)
{
throw new ArgumentException("Invalid layout member (No Return Type)");
}
_member = layoutMember;
_typeName = typeName;
_symbols = symbolProvider;
// Watch out for order(?
_conditions = conditions.SelectMany(x => x.GetResolvers(layoutMember, _throwCollection)).ToList();
_format = GetFormatResolver();
IMemberDataFormatter GetFormatResolver()
{
foreach (var formatter in formatters)
{
if (!formatter.ShouldFormat(layoutMember))
{
continue;
}
return(formatter.GetFormatter(layoutMember, _componentCollection, _throwCollection));
}
throw new ArgumentException($"The target member {layoutMember.Name} cannot be resolved by any of the provided {nameof(IMemberDataFormatterProvider)}");
}
}
public MemberComposerSourceProto(MemberMetaInfo layoutMember, GeneratingTypeName typeName, IEnumerable <IMemberComposingFeature> features, ITypeSymbolProvider symbolProvider)
{
if (_member.ReturnType is null)
{
throw new ArgumentException("Invalid layout member (No Return Type)");
}
_member = layoutMember;
_typeName = typeName;
_symbols = symbolProvider;
_features = features.Where(x => x.ShouldFormat(layoutMember)).Select(x => x.GetComposingMethods(layoutMember, _componentCollection, _throwCollection)).ToList();
}
public BinaryMemberCompositeBuilder(MemberMetaInfo member,
GeneratingTypeName typeName,
IMemberFormatNamespaceProvider namespaceProvider,
IEnumerable <IBinaryMemberFeatureProvider> featureProviders,
ISourceAddition sourceAddition)
{
_member = member;
_typeName = typeName;
_sourceAddition = sourceAddition;
_features = featureProviders.Where(feature => feature.ShouldApply(member))
.Select(feature => feature.GetComposingMethods(member, _memberComponents, _throwCollection))
.ToList();
var namespaceInfo = namespaceProvider.GetUsingNamespaces(member);
_normalNamespaces = namespaceInfo.WithNamespaces.ToList();
_prioritizedNamespaces = namespaceInfo.WithPrioritizedNamespaces.ToList();
Debug.Assert(_member.ReturnType != null);
}
public BinaryMemberCompositeStruct AddMemberCompositeStruct(MemberMetaInfo member, GeneratingTypeName typeName, IComponentResolver resolver)
{
return(new BinaryMemberCompositeBuilder(member, typeName, _namespaceProvider, _featureProviders, _sourceAddition).AddStructToSource(resolver));
}
private MethodSignature TryPattern(GeneratingTypeName fullName, IComponentProvider provider) => MethodSignatureBuilder.CreateConstructor(fullName, (provider.DiscoveryType, discovery), (RefKind.Out, _symbolSource.GetSymbol <bool>(), isSuccess));
private MethodSignature NonTryPattern(GeneratingTypeName fullName, IComponentProvider provider) => MethodSignatureBuilder.CreateConstructor(fullName, (provider.DiscoveryType, discovery));
public IMemberComposer Build(ITypeComposer typeComposer, MemberMetaInfo meta, GeneratingTypeName typeName, IComponentProvider provider)
=> new MemberComposerSource(meta, typeName, _conditions, _formatters, _symbolProvider)
.CreateStruct(typeComposer, provider, (name, source) => {
_sourceAddition.AddSource($"{typeName}.generated.cs", source);
return(_symbolProvider.GetSymbol(name.ToString()));
});
public TypeComposer AddStructToSource(IBinarySchema schema, IComponentResolver resolver, GeneratingTypeName typeName, Func <MemberMetaInfo, GeneratingTypeName> memberCompositeNameProvider)
{
const string discovery = nameof(discovery);
var mCompositName = schema.SerializeOrder.Select(x => memberCompositeNameProvider(x)).ToList();
var composites = schema.SerializeOrder.Select((x, i) => _memberFactory.AddMemberCompositeStruct(x, mCompositName[i], resolver)).ToList();
var builder = new CodeSourceFileBuilder(typeName.Namespace);
builder.Using("System");
builder.Using("System.Collections.Generic");
builder.AttributeHideEditor();
builder.AttributeGenerated(typeof(BinaryTypeCompositeBuilder).Assembly);
builder.NestType(typeName, $"internal readonly struct {typeName.TypeName}", node => {
for (var i = 0; i < mCompositName.Count; ++i)
{
node.State($"public {mCompositName[i]} {Property.MemberName(i)} {{ get; }}");
}
node.State($"public static IReadOnlyList<int?> BinaryLength {{ get; }} = new int?[] {{ {string.Join(",", composites.Select(x => x.ConstantLength))} }}");
node.NewLine();
node.AddNode($"public {typeName.TypeName} ({typeof(IBinaryNamespaceDiscovery).FullName} {discovery})", node => {
for (var i = 0; i < mCompositName.Count; ++i)
{
node.State($"{Property.MemberName(i)} = new {mCompositName[i]} ({discovery})");
}
}).NewLine();
// Serialize Span
node.AddMethod(_methods.SerializeSpan, node => {
});
node.AddMethod(_methods.SerializeWriter, node => {
});
node.AddMethod(_methods.DeserializeSpan, node => {
});
node.AddMethod(_methods.DeserializeCursor, node => {
});
node.AddMethod(_methods.GetSpanLength, node => {
node.Return(string.Join("+ ", composites.Select(stringCompose)));
string stringCompose(BinaryMemberCompositeStruct composite)
{
if (composite.ConstantLength.HasValue)
{
return(composite.ConstantLength.ToString());
}
var typeParams = _methods.GetSpanLength.TypeParameters.Select(x => x.GenericName);
var args = _methods.GetSpanLength.Arguments.Select(x => x.ArgName);
return(new BinaryConverterMethods(composite.Name, schema.SourceType.Symbol).GetSpanLength.GetInvocationString(typeParams, args));
}
});
node.AddMethod(_methods.GetBlockLengthSpan, node => {
const string length = nameof(length);
var currentIteration = 0;
node.State($"var {length} = 0");
for (var i = 0; i < composites.Count; ++i)
{
}
});
});
}
