protected void AddConstructorAssignedField( TypeReferenceBuilder type, string fieldName, ClassBuilder classBuilder, ConstructorBuilder constructorBuilder, bool skipNullCheck = false) { var paramName = fieldName.TrimStart('_'); classBuilder.AddField() .SetReadOnly() .SetName(fieldName) .SetType(type); AssignmentBuilder assignment = AssignmentBuilder .New() .SetLefthandSide(fieldName) .SetRighthandSide(paramName); if (!skipNullCheck) { assignment.AssertNonNull(); } constructorBuilder .AddCode(assignment) .AddParameter(paramName, b => b.SetType(type)); }
public void IfAddFieldIsCalledTwiceWithTheSameFieldNameShouldThrowException() { var builder = new ClassBuilder(ClassName); builder.AddField <string>(FirstFieldName).AddField <string>(FirstFieldName).GetDeclaration(); }
public void IfAddFieldValueToExistingFieldShouldNotThrowException() { var builder = new ClassBuilder(ClassName); var target = builder.AddField <string>(FirstFieldName).AddFieldValue(FirstFieldName, FirstFieldValue).GetDeclaration(); Assert.IsNotNull(target); }
protected override void Generate( InputObjectTypeDescriptor descriptor, CSharpSyntaxGeneratorSettings settings, CodeWriter writer, out string fileName, out string?path, out string ns) { const string serializerResolver = nameof(serializerResolver); const string runtimeValue = nameof(runtimeValue); const string input = nameof(input); const string inputInfo = nameof(inputInfo); const string fields = nameof(fields); fileName = CreateInputValueFormatter(descriptor); path = Serialization; ns = descriptor.RuntimeType.NamespaceWithoutGlobal; string stateNamespace = $"{descriptor.RuntimeType.Namespace}.{State}"; string infoInterfaceType = $"{stateNamespace}.{CreateInputValueInfo(descriptor.Name)}"; ClassBuilder classBuilder = ClassBuilder .New() .SetName(fileName) .AddImplements(TypeNames.IInputObjectFormatter); var neededSerializers = descriptor .Properties .GroupBy(x => x.Type.Name) .ToDictionary(x => x, x => x.First()); // Initialize Method CodeBlockBuilder initialize = classBuilder .AddMethod("Initialize") .SetPublic() .AddParameter(serializerResolver, x => x.SetType(TypeNames.ISerializerResolver)) .AddBody(); foreach (var property in neededSerializers.Values) { if (property.Type.GetName().Value is { } name) { var propertyName = GetFieldName(name) + "Formatter"; initialize .AddAssigment(propertyName) .AddMethodCall() .SetMethodName(serializerResolver, "GetInputValueFormatter") .AddArgument(name.AsStringToken()); classBuilder .AddField(propertyName) .SetAccessModifier(AccessModifier.Private) .SetType(TypeNames.IInputValueFormatter) .SetValue("default!"); }
private void FieldAddButton_Click(object sender, EventArgs e) { MemberAttributes attr = MemberAttributes.Public; switch (FieldAccessBox.Text) { case "public": attr = MemberAttributes.Public; break; case "protected": attr = MemberAttributes.Family; break; case "private": attr = MemberAttributes.Private; break; default: break; } switch (FieldTypeBox.Text) { case "string": _currentClassBuilder.AddField <string>(FieldNameBox.Text, attr); break; case "int": _currentClassBuilder.AddField <int>(FieldNameBox.Text, attr); break; case "bool": _currentClassBuilder.AddField <bool>(FieldNameBox.Text, attr); break; default: break; } UpdateClassMembers(); FieldNameBox.Text = ""; }
public void IfAddFieldIsCalledShouldAddFieldToDeclaration() { var builder = new ClassBuilder(ClassName); var target = builder.AddField <string>(FirstFieldName).GetDeclaration(); Assert.AreEqual(1, target.Members.Count); var member = target.Members[0]; Assert.AreEqual(FirstFieldName, member.Name); }
protected override void Generate( CodeWriter writer, InputObjectTypeDescriptor namedTypeDescriptor, out string fileName, out string?path) { const string serializerResolver = nameof(serializerResolver); const string runtimeValue = nameof(runtimeValue); const string value = nameof(value); fileName = CreateInputValueFormatter(namedTypeDescriptor); path = Serialization; NameString typeName = namedTypeDescriptor.Name; ClassBuilder classBuilder = ClassBuilder .New() .SetName(fileName) .AddImplements(TypeNames.IInputObjectFormatter); var neededSerializers = namedTypeDescriptor .Properties .GroupBy(x => x.Type.Name) .ToDictionary(x => x, x => x.First()); // Initialize Method CodeBlockBuilder initialize = classBuilder .AddMethod("Initialize") .SetPublic() .AddParameter(serializerResolver, x => x.SetType(TypeNames.ISerializerResolver)) .AddBody(); foreach (var property in neededSerializers.Values) { if (property.Type.GetName().Value is { } name) { var propertyName = GetFieldName(name) + "Formatter"; initialize .AddAssigment(propertyName) .AddMethodCall() .SetMethodName( serializerResolver, "GetInputValueFormatter") .AddArgument(name.AsStringToken()); classBuilder .AddField(propertyName) .SetAccessModifier(AccessModifier.Private) .SetType(TypeNames.IInputValueFormatter) .SetValue("default!"); }
private static void AddInjectedSerializers( OperationDescriptor descriptor, ConstructorBuilder constructorBuilder, ClassBuilder classBuilder) { var neededSerializers = descriptor .Arguments .GroupBy(x => x.Type.Name) .ToDictionary(x => x.Key, x => x.First()); if (!neededSerializers.Any()) { return; } constructorBuilder .AddParameter(_serializerResolver) .SetType(TypeNames.ISerializerResolver); foreach (var property in neededSerializers.Values) { if (property.Type.GetName().Value is { } name) { var fieldName = $"{GetFieldName(name)}Formatter"; constructorBuilder .AddCode( AssignmentBuilder .New() .SetLefthandSide(fieldName) .SetRighthandSide( MethodCallBuilder .Inline() .SetMethodName( _serializerResolver, "GetInputValueFormatter") .AddArgument(name.AsStringToken()))); classBuilder .AddField() .SetName(fieldName) .SetAccessModifier(AccessModifier.Private) .SetType(TypeNames.IInputValueFormatter) .SetReadOnly(); }
protected override void Generate( CodeWriter writer, ResultBuilderDescriptor resultBuilderDescriptor, out string fileName, out string?path) { InterfaceTypeDescriptor resultTypeDescriptor = resultBuilderDescriptor.ResultNamedType as InterfaceTypeDescriptor ?? throw new InvalidOperationException( "A result type can only be generated for complex types"); fileName = resultBuilderDescriptor.RuntimeType.Name; path = State; ClassBuilder classBuilder = ClassBuilder .New() .SetName(fileName); ConstructorBuilder constructorBuilder = classBuilder .AddConstructor() .SetTypeName(fileName); classBuilder .AddImplements( TypeNames.IOperationResultBuilder.WithGeneric( TypeNames.JsonDocument, resultTypeDescriptor.RuntimeType.ToString())); AddConstructorAssignedField( TypeNames.IEntityStore, _entityStore, classBuilder, constructorBuilder); AddConstructorAssignedField( TypeNames.IEntityIdSerializer, _idSerializer, classBuilder, constructorBuilder); AddConstructorAssignedField( TypeNames.IOperationResultDataFactory .WithGeneric(resultTypeDescriptor.RuntimeType.ToString()), _resultDataFactory, classBuilder, constructorBuilder); constructorBuilder .AddParameter(_serializerResolver) .SetType(TypeNames.ISerializerResolver); IEnumerable <ValueParserDescriptor> valueParsers = resultBuilderDescriptor .ValueParsers .GroupBy(t => t.Name) .Select(t => t.First()); foreach (ValueParserDescriptor valueParser in valueParsers) { var parserFieldName = $"{GetFieldName(valueParser.Name)}Parser"; classBuilder .AddField(parserFieldName) .SetReadOnly() .SetType( TypeNames.ILeafValueParser .WithGeneric(valueParser.SerializedType, valueParser.RuntimeType)); MethodCallBuilder getLeaveValueParser = MethodCallBuilder .Inline() .SetMethodName(_serializerResolver, "GetLeafValueParser") .AddGeneric(valueParser.SerializedType.ToString()) .AddGeneric(valueParser.RuntimeType.ToString()) .AddArgument(valueParser.Name.AsStringToken()); constructorBuilder.AddCode( AssignmentBuilder .New() .SetAssertNonNull() .SetAssertException( ExceptionBuilder .Inline(TypeNames.ArgumentException) .AddArgument( $"\"No serializer for type `{valueParser.Name}` found.\"")) .SetLefthandSide(parserFieldName) .SetRighthandSide(getLeaveValueParser)); } AddBuildMethod(resultTypeDescriptor, classBuilder); AddBuildDataMethod(resultTypeDescriptor, classBuilder); var processed = new HashSet <string>(); AddRequiredDeserializeMethods(resultTypeDescriptor, classBuilder, processed); CodeFileBuilder .New() .SetNamespace(resultBuilderDescriptor.RuntimeType.NamespaceWithoutGlobal) .AddType(classBuilder) .Build(writer); }
protected override void Generate(EntityIdFactoryDescriptor descriptor, CSharpSyntaxGeneratorSettings settings, CodeWriter writer, out string fileName, out string?path, out string ns) { fileName = descriptor.Name; path = State; ns = descriptor.Namespace; ClassBuilder classBuilder = ClassBuilder .New() .SetAccessModifier(AccessModifier.Public) .AddImplements(TypeNames.IEntityIdSerializer) .SetName(fileName); classBuilder .AddField(_options) .SetStatic() .SetReadOnly() .SetType(TypeNames.JsonWriterOptions) .SetValue(CodeBlockBuilder .New() .AddCode(MethodCallBuilder .Inline() .SetNew() .SetMethodName(TypeNames.JsonWriterOptions)) .AddCode(CodeInlineBuilder.From("{ Indented = false }"))); classBuilder .AddMethod("Parse") .SetAccessModifier(AccessModifier.Public) .SetReturnType(TypeNames.EntityId) .AddParameter(_obj, x => x.SetType(TypeNames.JsonElement)) .AddCode(ParseEntityIdBody(descriptor)); classBuilder .AddMethod("Format") .SetAccessModifier(AccessModifier.Public) .SetReturnType(TypeNames.String) .AddParameter(_entityId, x => x.SetType(TypeNames.EntityId)) .AddCode(FormatEntityIdBody(descriptor)); foreach (var entity in descriptor.Entities) { classBuilder .AddMethod($"Parse{entity.Name}EntityId") .SetAccessModifier(AccessModifier.Private) .SetReturnType(TypeNames.EntityId) .AddParameter(_obj, x => x.SetType(TypeNames.JsonElement)) .AddParameter(_type, x => x.SetType(TypeNames.String)) .AddCode(ParseSpecificEntityIdBody(entity)); classBuilder .AddMethod($"Format{entity.Name}EntityId") .SetAccessModifier(AccessModifier.Private) .SetReturnType(TypeNames.String) .AddParameter(_entityId, x => x.SetType(TypeNames.EntityId)) .AddCode(FormatSpecificEntityIdBody(entity)); } classBuilder.Build(writer); }
public override void Build(RuntimeState state, ClassBuilder builder) { builder.AddField(name.name); }