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