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