public CodeGenMethod Create(DecoratorMethodInformation factoryInformation)
{
IEnumerable <CodeGenGeneric> genericTypes = factoryInformation.GenericTypes?.Select(
parameter => FactoryHelpers.GenerateMethodParameter(parameter, factoryInformation.TypeConstraints));
IEnumerable <string> parameters = factoryInformation.Parameters?.Select(parameter => $"{parameter.Type} {parameter.Name}");
MethodTemplate matchingTemplate = _SelectorFactory
.Create(factoryInformation.Templates)
.Select(
factoryInformation.MethodName,
factoryInformation.ReturnType,
factoryInformation.Parameters?.Select(parameter => parameter.Type)?.ToArray(),
factoryInformation.IsAsync);
string body = matchingTemplate != null
? GenerateDecoratorMethodBodyFromCondition(
factoryInformation.MethodName,
factoryInformation.ReturnType,
matchingTemplate,
factoryInformation.Parameters)
: GenerateUndecoratedMethodBody(
factoryInformation.MethodName,
factoryInformation.Parameters);
return(new CodeGenMethod(
factoryInformation.MethodName,
factoryInformation.ReturnType,
Scope.Public,
MethodType.Normal,
genericTypes,
parameters,
body,
matchingTemplate?.Async ?? false));
}
private string GenerateDecoratorPropertySetterBodyFromCondition(string propertyName, PropertyTemplate template)
{
string body = template.SetterBody.Clone() as string;
body = body.Replace("Decorated.Property.Any.Value", $"_Decorated.{propertyName}");
return(FactoryHelpers.CleanBody(body));
}
public CodeGenClass Create(DecoratorClassInformation factoryInformation)
{
var generatedExtensionClass = new CodeGenClass(
$"{factoryInformation.ParentInformation.DecoratorName}Extensions",
Scope.Public,
ClassType.Static);
IEnumerable <CodeGenGeneric> genericTypes = factoryInformation.GenericTypes?.Select(
parameter => FactoryHelpers.GenerateMethodParameter(parameter, factoryInformation.TypeConstraints));
var extensionParams = new List <string>(new[] { $"this {factoryInformation.DecoratedType} decorated" });
var decoratedConstructorParams = new List <string>(new[] { "decorated" });
if (factoryInformation.Template.ConstructorParams != null)
{
foreach (ConstructorParam constructorParam in factoryInformation.Template.ConstructorParams)
{
extensionParams.Add($"{constructorParam.Type} {constructorParam.Name}");
decoratedConstructorParams.Add(constructorParam.Name);
}
}
string genericTypesString = factoryInformation.GenericTypes.ToTypeParamList();
string paramNames = string.Join(", ", decoratedConstructorParams);
string body = $"return new {factoryInformation.ParentInformation.DecoratorName}{genericTypesString}({paramNames});";
string returnType = factoryInformation.DerviedFrom != null
? factoryInformation.DerviedFrom
: $"{factoryInformation.ParentInformation.DecoratorName}{genericTypesString}";
var generatedExtensionMethod = new CodeGenMethod(
$"DecorateWith{factoryInformation.Template.Label}",
returnType,
Scope.Public,
MethodType.Static,
genericTypes,
extensionParams,
body);
generatedExtensionClass.Methods.Add(generatedExtensionMethod);
return(generatedExtensionClass);
}
private string GenerateDecoratorMethodBodyFromCondition(
string methodName,
string returnType,
MethodTemplate template,
IEnumerable <MethodParameter> parameters)
{
IEnumerable <string> paramNameList = parameters?.Select(parameter => parameter.Name) ?? new string[0];
string invocation = $"_Decorated.{methodName}({string.Join(", ", paramNameList)})";
string body = template.Body.Clone() as string;
if (returnType == "void" && template.MatchCondition.ReturnTypeRule == ReturnTypeRule.Any)
{
body = VoidReturnMethodInvokeRegex.Replace(body, invocation);
}
else
{
body = MethodInvokeRegex.Replace(body, invocation);
}
return(FactoryHelpers.CleanBody(body));
}
public CodeGenClass Create(DecoratorClassInformation factoryInformation)
{
IEnumerable <CodeGenGeneric> genericTypes = factoryInformation.GenericTypes?.Select(
parameter => FactoryHelpers.GenerateMethodParameter(parameter, factoryInformation.TypeConstraints));
string[] derivedFrom = !string.IsNullOrEmpty(factoryInformation.DerviedFrom)
? new[] { factoryInformation.DerviedFrom }
: null;
var generatedDecoratorClass = new CodeGenClass(
factoryInformation.ParentInformation.DecoratorName,
Scope.Public,
ClassType.Normal,
genericTypes,
derivedFrom);
generatedDecoratorClass.Comment = new CodeGenComment($@"Generated {factoryInformation.Template.Label} decorator for the {factoryInformation.DecoratedType } type. Auto-generated on {DateTimeOffset.Now}");
var constructorParams = new List <string>(new[] { $"{factoryInformation.DecoratedType} decorated" });
var constructorBodyBuilder = new StringBuilder();
constructorBodyBuilder.AppendLine("_Decorated = decorated ?? throw new ArgumentNullException(nameof(decorated));");
if (factoryInformation.Template.ConstructorParams != null)
{
foreach (ConstructorParam constructorParam in factoryInformation.Template.ConstructorParams)
{
constructorParams.Add($"{constructorParam.Type} {constructorParam.Name}");
constructorBodyBuilder.AppendLine($"_{constructorParam.Name} = {constructorParam.Name};");
generatedDecoratorClass.Variables.Add(new CodeGenVariable(
$"_{constructorParam.Name}",
constructorParam.Type,
Scope.Private,
readOnly: true));
}
}
// Constructor
generatedDecoratorClass.Constructors.Add(new CodeGenConstructor(
factoryInformation.ParentInformation.DecoratorName,
Scope.Public,
constructorParams,
constructorBodyBuilder.ToString()));
// Decorated variable
generatedDecoratorClass.Variables.Add(new CodeGenVariable(
"_Decorated",
factoryInformation.DecoratedType,
Scope.Private,
readOnly: true));
foreach (DecoratorMethodInformation methodInformation in factoryInformation.MethodInformation)
{
CodeGenMethod method = _MethodFactory.Create(methodInformation);
generatedDecoratorClass.Methods.Add(method);
}
foreach (DecoratorPropertyInformation propertyInformation in factoryInformation.PropertyInformation)
{
CodeGenProperty property = _PropertyFactory.Create(propertyInformation);
generatedDecoratorClass.Properties.Add(property);
}
return(generatedDecoratorClass);
}