private void GenerateICausesInterfaceImplementation(ClassGenerator @class, GenerationContext context)
{
if (ImplementsICauses(out string?eventClassName) &&
context.GetSourceClass(eventClassName) is Some <SourceClass> eventClassValue)
{
SourceClass eventClass = eventClassValue;
List <ParameterInfo> builderParams = new List <ParameterInfo>();
eventClass.GetBuilderConstructorParameters(builderParams);
int parameterCount = builderParams.Count;
MethodDeclarationSyntax buildEventMethod = MethodDeclaration(returnType: eventClass.NameSyntax, Identifier("BuildEvent"))
.AddModifiers(Token(SyntaxKind.PublicKeyword))
.AddBodyStatements(
ReturnStatement(
InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
ObjectCreationExpression(IdentifierName(eventClass.BuilderClassName))
.AddArgumentListArguments(
Enumerable.Repeat(Argument(ThisExpression()), parameterCount).ToArray()),
IdentifierName("Build")))));
@class.AddMembers(buildEventMethod);
}
}
private void GenerateIBuildsInterfaceImplementation(ClassGenerator @class)
{
@class.AddBaseType(GenericName("IBuilds").AddTypeArgumentListArguments(NameSyntax));
MethodDeclarationSyntax buildMethod = MethodDeclaration(returnType: NameSyntax, Identifier("Build"))
.AddModifiers(Token(SyntaxKind.PublicKeyword))
.AddBodyStatements(
ReturnStatement(
ObjectCreationExpression(NameSyntax)
.AddArgumentListArguments(Argument(ThisExpression()))));
ConversionOperatorDeclarationSyntax implicitCastOperator =
ConversionOperatorDeclaration(Token(SyntaxKind.ImplicitKeyword), NameSyntax)
.AddModifiers(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.StaticKeyword))
.AddParameterListParameters(
Parameter(Identifier("builder"))
.WithType(IdentifierName(BuilderClassName)))
.AddBodyStatements(
ReturnStatement(
InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName("builder"),
IdentifierName("Build")))));
if (BaseClass != null)
{
buildMethod = buildMethod.AddModifiers(Token(SyntaxKind.NewKeyword));
}
@class.AddMembers(buildMethod, implicitCastOperator);
}
private void GenerateAdditionalConstructors(ClassGenerator @class)
{
List <ParameterInfo> parameters = new List <ParameterInfo>();
var ctor = @class
.AddConstructor();
if (BaseClass != null)
{
BaseClass.GetBuilderConstructorParameters(parameters);
foreach (ParameterInfo p in parameters)
{
ctor.AddOptionalParameter(p.Type, p.Name).PassToBaseConstructor();
}
}
ParameterInfo[] additionalParams = GetAdditionalBuilderConstructorParameters().ToArray();
foreach (ParameterInfo p in additionalParams)
{
ctor.AddOptionalParameter(p.Type, p.Name).AddPropertyAssignmentBlock(AssignmentTarget.BuilderClass);
}
if (parameters.Any() || additionalParams.Any())
{
// Default constructor
@class.AddConstructor();
}
}
private void GenerateBuilderConstructor(ClassGenerator @class)
{
var ctor = @class
.AddConstructor();
var p = ctor
.AddOptionalParameter(this, "source")
.AddPropertyAssignmentBlock(AssignmentTarget.BuilderClass);
if (BaseClass != null)
{
p.PassToBaseConstructor();
}
}
private ClassDeclarationSyntax GenerateBuilderClass(GenerationContext context)
{
ClassGenerator @class = new ClassGenerator(Declaration, BuilderClassName);
@class.AddMembers(
Properties.SelectMany(p => PropertyRule
.GetRule(p)
.GenerateBuilderPropertyDeclarations(p))
.ToArray());
if (BaseClass != null)
{
@class.AddBaseType(IdentifierName(BaseClass.BuilderClassName));
}
GenerateIBuildsInterfaceImplementation(@class);
GenerateBuilderConstructor(@class);
GenerateAdditionalConstructors(@class);
return(@class.Generate());
}
private ClassDeclarationSyntax GeneratePartialClassCompletion(GenerationContext context)
{
ClassGenerator classGen = new ClassGenerator(Declaration);
var p = classGen.AddConstructor()
.AddRequiredParameter(this, BuilderClassName, "source")
.AddPropertyAssignmentBlock(AssignmentTarget.SourceClass);
if (BaseClass != null)
{
p.PassToBaseConstructor();
}
p = classGen.AddConstructor()
.AddRequiredParameter(this, Name, "source")
.AddPropertyAssignmentBlock(AssignmentTarget.SourceToSource);
if (BaseClass != null)
{
p.PassToBaseConstructor();
}
classGen.AddAttribute(
Attribute(IdentifierName("Builder")).AddArgumentListArguments(
AttributeArgument(
TypeOfExpression(IdentifierName(BuilderClassName)))));
classGen.AddMembers(GenerateMutateMethod());
foreach (SourceInterface i in Interfaces)
{
classGen.ImplementInterface(i);
}
GenerateICausesInterfaceImplementation(classGen, context);
return(classGen.Generate());
}
