internal static MethodDeclarationSyntax CreateIEnumerableFromParamsArrayMethod(MetaField field, MethodDeclarationSyntax paramsArrayMethod)
{
return(paramsArrayMethod
.WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Parameter(ValuesParameterName.Identifier)
.WithType(Syntax.IEnumerableOf(GetFullyQualifiedSymbolName(field.ElementType)))))));
}
private void ImplementIEnumerableInterfaces()
{
this.baseTypes.Add(SyntaxFactory.SimpleBaseType(Syntax.IEnumerableOf(this.generator.applyToMetaType.RecursiveType.TypeSyntax)));
// return this.<#=templateType.RecursiveField.NameCamelCase#>.GetEnumerator();
var body = SyntaxFactory.Block(
SyntaxFactory.ReturnStatement(
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
Syntax.ThisDot(SyntaxFactory.IdentifierName(this.generator.applyToMetaType.RecursiveField.Name)),
SyntaxFactory.IdentifierName(nameof(IEnumerable <int> .GetEnumerator))),
SyntaxFactory.ArgumentList())));
// public System.Collections.Generic.IEnumerator<RecursiveType> GetEnumerator()
this.innerMembers.Add(
SyntaxFactory.MethodDeclaration(
Syntax.IEnumeratorOf(GetFullyQualifiedSymbolName(this.generator.applyToMetaType.RecursiveField.ElementType)),
nameof(IEnumerable <int> .GetEnumerator))
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword))
.WithBody(body));
// System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
this.innerMembers.Add(
SyntaxFactory.MethodDeclaration(
Syntax.GetTypeSyntax(typeof(System.Collections.IEnumerator)),
nameof(IEnumerable <int> .GetEnumerator))
.WithExplicitInterfaceSpecifier(
SyntaxFactory.ExplicitInterfaceSpecifier(
SyntaxFactory.QualifiedName(
SyntaxFactory.QualifiedName(
SyntaxFactory.IdentifierName(nameof(System)),
SyntaxFactory.IdentifierName(nameof(System.Collections))),
SyntaxFactory.IdentifierName(nameof(System.Collections.IEnumerable)))))
.WithBody(body));
}
private void ImplementRecursiveParentInterface()
{
var irecursiveParentOfT = CreateIRecursiveParentOfTSyntax(GetFullyQualifiedSymbolName(this.generator.applyToMetaType.RecursiveType.TypeSymbol));
this.baseTypes.Add(SyntaxFactory.SimpleBaseType(irecursiveParentOfT));
// return this.Children;
var returnThisDotChildren = SyntaxFactory.ReturnStatement(Syntax.ThisDot(SyntaxFactory.IdentifierName(this.generator.applyToMetaType.RecursiveField.Name.ToPascalCase())));
// System.Collections.Generic.IEnumerable<IRecursiveType> IRecursiveParent.Children
this.innerMembers.Add(
SyntaxFactory.PropertyDeclaration(
Syntax.GetTypeSyntax(typeof(IEnumerable <IRecursiveType>)),
nameof(IRecursiveParent.Children))
.WithExplicitInterfaceSpecifier(SyntaxFactory.ExplicitInterfaceSpecifier(Syntax.GetTypeSyntax(typeof(IRecursiveParent))))
.AddAccessorListAccessors(SyntaxFactory.AccessorDeclaration(
SyntaxKind.GetAccessorDeclaration,
SyntaxFactory.Block(returnThisDotChildren))));
// public ParentedRecursiveType<TRecursiveParent, TRecursiveType> GetParentedNode(uint identity)
this.innerMembers.Add(
SyntaxFactory.MethodDeclaration(
SyntaxFactory.GenericName(nameof(ParentedRecursiveType <IRecursiveParent <IRecursiveType>, IRecursiveType>)).AddTypeArgumentListArguments(
this.applyTo.RecursiveParent.TypeSyntax,
this.applyTo.RecursiveType.TypeSyntax),
nameof(IRecursiveParent.GetParentedNode))
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword))
//.WithExplicitInterfaceSpecifier(SyntaxFactory.ExplicitInterfaceSpecifier(Syntax.GetTypeSyntax(typeof(IRecursiveParent))))
.AddParameterListParameters(RequiredIdentityParameter)
.WithBody(SyntaxFactory.Block(
// return this.GetParentedNode<TRecursiveParent, TRecursiveType>(identity);
SyntaxFactory.ReturnStatement(
SyntaxFactory.InvocationExpression(
Syntax.ThisDot(SyntaxFactory.GenericName(nameof(RecursiveTypeExtensions.GetParentedNode)).AddTypeArgumentListArguments(
this.applyTo.RecursiveParent.TypeSyntax,
this.applyTo.RecursiveType.TypeSyntax)))
.AddArgumentListArguments(SyntaxFactory.Argument(IdentityParameterName))))));
// ParentedRecursiveType<IRecursiveParent<IRecursiveType>, IRecursiveType> IRecursiveParent.GetParentedNode(<#= templateType.RequiredIdentityField.TypeName #> identity) {
var parentedVar = SyntaxFactory.IdentifierName("parented");
var returnType = Syntax.GetTypeSyntax(typeof(ParentedRecursiveTypeNonGeneric));
this.innerMembers.Add(
SyntaxFactory.MethodDeclaration(
returnType,
nameof(IRecursiveParent.GetParentedNode))
.WithExplicitInterfaceSpecifier(SyntaxFactory.ExplicitInterfaceSpecifier(Syntax.GetTypeSyntax(typeof(IRecursiveParent))))
.AddParameterListParameters(RequiredIdentityParameter)
.WithBody(SyntaxFactory.Block(
// var parented = this.GetParentedNode(identity);
SyntaxFactory.LocalDeclarationStatement(SyntaxFactory.VariableDeclaration(varType).AddVariables(
SyntaxFactory.VariableDeclarator(parentedVar.Identifier).WithInitializer(SyntaxFactory.EqualsValueClause(
SyntaxFactory.InvocationExpression(Syntax.ThisDot(SyntaxFactory.IdentifierName(nameof(RecursiveTypeExtensions.GetParentedNode))))
.AddArgumentListArguments(SyntaxFactory.Argument(IdentityParameterName)))))),
// return new ParentedRecursiveType<IRecursiveParent<IRecursiveType>, IRecursiveType>(parented.Value, parented.Parent);
SyntaxFactory.ReturnStatement(SyntaxFactory.ObjectCreationExpression(returnType).AddArgumentListArguments(
SyntaxFactory.Argument(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, parentedVar, SyntaxFactory.IdentifierName(nameof(ParentedRecursiveTypeNonGeneric.Value)))),
SyntaxFactory.Argument(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, parentedVar, SyntaxFactory.IdentifierName(nameof(ParentedRecursiveTypeNonGeneric.Parent)))))))));
////System.Collections.Generic.IEnumerable<<#= templateType.RecursiveType.TypeName #>> IRecursiveParent<<#= templateType.RecursiveType.TypeName #>>.Children {
//// get { return this.Children; }
////}
this.innerMembers.Add(
SyntaxFactory.PropertyDeclaration(
Syntax.IEnumerableOf(this.generator.applyToMetaType.RecursiveType.TypeSyntax),
nameof(IRecursiveParent <IRecursiveType> .Children))
.WithExplicitInterfaceSpecifier(SyntaxFactory.ExplicitInterfaceSpecifier(irecursiveParentOfT))
.AddAccessorListAccessors(SyntaxFactory.AccessorDeclaration(
SyntaxKind.GetAccessorDeclaration,
SyntaxFactory.Block(returnThisDotChildren))));
}
