Class CodeFactory


  • public class CodeFactory
    extends SubFactory
    This sub-factory contains utility methods to create code elements. To avoid over-using reflection, consider using Template.
    • Constructor Detail

    • Method Detail

      • createBinaryOperator

        public <T> CtBinaryOperator<T> createBinaryOperator​(CtExpression<?> left,
                                                            CtExpression<?> right,
                                                            BinaryOperatorKind kind)
        Creates a binary operator.
        Type Parameters:
        T - the type of the expression
        Parameters:
        left - the left operand
        right - the right operand
        kind - the operator kind
        Returns:
        a binary operator expression
      • createTypeAccess

        public <T> CtTypeAccess<T> createTypeAccess​(CtTypeReference<T> accessedType)
        Creates a accessed type.

        This method sets a clone of the given accessedType object to the accessedType field of the returned CtTypeAccess. If the given accessedType is unique and cloning is not needed, use createTypeAccessWithoutCloningReference(CtTypeReference) instead of this method.

        Type Parameters:
        T - the type of the expression.
        Parameters:
        accessedType - a type reference to the accessed type.
        Returns:
        a accessed type expression.
      • createTypeAccess

        public <T> CtTypeAccess<T> createTypeAccess​(CtTypeReference<T> accessedType,
                                                    boolean isImplicit)
        Creates a accessed type.

        This method sets a clone of the given accessedType object to the accessedType field of the returned CtTypeAccess. If the given accessedType is unique and cloning is not needed, use createTypeAccessWithoutCloningReference(CtTypeReference) instead of this method.

        Type Parameters:
        T - the type of the expression.
        Parameters:
        accessedType - a type reference to the accessed type.
        isImplicit - type of the type access is implicit or not.
        Returns:
        a accessed type expression.
      • createTypeAccessWithoutCloningReference

        public <T> CtTypeAccess<T> createTypeAccessWithoutCloningReference​(CtTypeReference<T> accessedType)
        Creates a accessed type, see createTypeAccess(CtTypeReference) for details.
        Type Parameters:
        T - the type of the expression.
        Parameters:
        accessedType - a type reference to the accessed type.
        Returns:
        a accessed type expression.
      • createClassAccess

        public <T> CtFieldAccess<java.lang.Class<T>> createClassAccess​(CtTypeReference<T> type)
        Creates a class access expression of the form C.class.
        Type Parameters:
        T - the actual type of the accessed class if available
        Parameters:
        type - a type reference to the accessed class
        Returns:
        the class access expression.
      • createConstructorCall

        public <T> CtConstructorCall<T> createConstructorCall​(CtTypeReference<T> type,
                                                              CtExpression<?>... parameters)
        Creates a constructor call. The correct constructor is inferred based on parameters
        Type Parameters:
        T - the actual type of the decelerating type of the constructor if available
        Parameters:
        type - the decelerating type of the constructor
        parameters - the arguments of the constructor call
        Returns:
        the constructor call
      • createNewClass

        public <T> CtNewClass<T> createNewClass​(CtType<T> superClass,
                                                CtExpression<?>... parameters)
        Creates a new anonymous class.
      • createInvocation

        public <T> CtInvocation<T> createInvocation​(CtExpression<?> target,
                                                    CtExecutableReference<T> executable,
                                                    CtExpression<?>... arguments)
        Creates an invocation (can be a statement or an expression).
        Type Parameters:
        T - the return type of the invoked method
        Parameters:
        target - the target expression
        executable - the invoked executable
        arguments - the argument list
        Returns:
        the new invocation
      • createInvocation

        public <T> CtInvocation<T> createInvocation​(CtExpression<?> target,
                                                    CtExecutableReference<T> executable,
                                                    java.util.List<CtExpression<?>> arguments)
        Creates an invocation (can be a statement or an expression).
        Type Parameters:
        T - the return type of the invoked method
        Parameters:
        target - the target expression (may be null for static methods)
        executable - the invoked executable
        arguments - the argument list
        Returns:
        the new invocation
      • createLiteral

        public <T> CtLiteral<T> createLiteral​(T value)
        Creates a literal with a given value.
        Type Parameters:
        T - the type of the literal
        Parameters:
        value - the value of the literal
        Returns:
        a new literal
      • createTextBlock

        public CtTextBlock createTextBlock​(java.lang.String value)
        Creates a TextBlock with the given string value.
        Parameters:
        value - the string value of the literal
        Returns:
        a new literal
      • createLiteralArray

        public <T> CtNewArray<T[]> createLiteralArray​(T[] value)
        Creates a one-dimension array that must only contain literals.
      • createLocalVariable

        public <T> CtLocalVariable<T> createLocalVariable​(CtTypeReference<T> type,
                                                          java.lang.String name,
                                                          CtExpression<T> defaultExpression)
        Creates a local variable declaration.
        Type Parameters:
        T - the local variable type
        Parameters:
        type - the reference to the type
        name - the name of the variable
        defaultExpression - the assigned default expression
        Returns:
        a new local variable declaration
      • createLocalVariableReference

        public <T> CtLocalVariableReference<T> createLocalVariableReference​(CtLocalVariable<T> localVariable)
        Creates a local variable reference that points to an existing local variable (strong referencing).
      • createLocalVariableReference

        public <T> CtLocalVariableReference<T> createLocalVariableReference​(CtTypeReference<T> type,
                                                                            java.lang.String name)
        Creates a local variable reference with its name an type (weak referencing).
      • createCatchVariable

        public <T> CtCatchVariable<T> createCatchVariable​(CtTypeReference<T> type,
                                                          java.lang.String name,
                                                          ModifierKind... modifierKinds)
        Creates a catch variable declaration.
        Type Parameters:
        T - the catch variable type
        Parameters:
        type - the reference to the type
        name - the name of the variable
        modifierKinds - Modifiers of the catch variable
        Returns:
        a new catch variable declaration
      • createCatchVariableReference

        public <T> CtCatchVariableReference<T> createCatchVariableReference​(CtCatchVariable<T> catchVariable)
        Creates a catch variable reference that points to an existing catch variable (strong referencing).
      • createStatementList

        public <R> CtStatementList createStatementList​(CtBlock<R> block)
        Creates a new statement list from an existing block.
      • createThisAccess

        public <T> CtThisAccess<T> createThisAccess​(CtTypeReference<T> type)
        Creates an explicit access to a this variable (of the form type.this).
        Type Parameters:
        T - the actual type of this
        Parameters:
        type - the reference to the type that holds the this variable
        Returns:
        a type.this expression
      • createThisAccess

        public <T> CtThisAccess<T> createThisAccess​(CtTypeReference<T> type,
                                                    boolean isImplicit)
        Creates an access to a this variable (of the form type.this).
        Type Parameters:
        T - the actual type of this
        Parameters:
        type - the reference to the type that holds the this variable
        isImplicit - type of the this access is implicit or not.
        Returns:
        a type.this expression
      • createVariableReads

        public java.util.List<CtExpression<?>> createVariableReads​(java.util.List<? extends CtVariable<?>> variables)
        Creates a list of variable accesses for read.
        Parameters:
        variables - the variables to be accessed
      • createVariableAssignment

        public <A,​T extends A> CtAssignment<A,​T> createVariableAssignment​(CtVariableReference<A> variable,
                                                                                      boolean isStatic,
                                                                                      CtExpression<T> expression)
        Creates a variable assignment (can be an expression or a statement).
        Type Parameters:
        T - the type of the assigned variable
        Parameters:
        variable - a reference to the assigned variable
        isStatic - tells if the assigned variable is static or not
        expression - the assigned expression
        Returns:
        a variable assignment
      • createVariableAssignments

        public <T> CtStatementList createVariableAssignments​(java.util.List<? extends CtVariable<T>> variables,
                                                             java.util.List<? extends CtExpression<T>> expressions)
        Creates a list of statements that contains the assignments of a set of variables.
        Parameters:
        variables - the variables to be assigned
        expressions - the assigned expressions
        Returns:
        a list of variable assignments
      • createCtField

        public <T> CtField<T> createCtField​(java.lang.String name,
                                            CtTypeReference<T> type,
                                            java.lang.String exp,
                                            ModifierKind... visibilities)
        Creates a field.
        Type Parameters:
        T - Generic type for the type of the field.
        Parameters:
        name - Name of the field.
        type - Type of the field.
        exp - Default expression of the field.
        visibilities - All visibilities of the field.
        Returns:
        a field
      • createCtBlock

        public <T extends CtStatementCtBlock<?> createCtBlock​(T element)
        Creates a block.
        Type Parameters:
        T - Subclasses of CtStatement.
        Parameters:
        element - Statement of the block.
        Returns:
        a block.
      • getOrCreateCtBlock

        public <T extends CtStatementCtBlock<?> getOrCreateCtBlock​(T element)
        Accepts instance of CtStatement or CtBlock. If element is CtStatement, then it creates wrapping CtBlock, which contains the element If element is CtBlock, then it directly returns that element If element is null, then it returns null. note: It must not create empty CtBlock - as expected in CtCatch, CtExecutable, CtLoop and CtTry setBody implementations
        Parameters:
        element -
        Returns:
        CtBlock instance
      • createCtThrow

        public CtThrow createCtThrow​(java.lang.String thrownExp)
        Creates a throw.
        Parameters:
        thrownExp - Expression of the throw.
        Returns:
        a throw.
      • createCtCatch

        public CtCatch createCtCatch​(java.lang.String nameCatch,
                                     java.lang.Class<? extends java.lang.Throwable> exception,
                                     CtBlock<?> ctBlock)
        Creates a catch element.
        Parameters:
        nameCatch - Name of the variable in the catch.
        exception - Type of the exception.
        ctBlock - Content of the catch.
        Returns:
        a catch.
      • createCtTypeReference

        public <T> CtTypeReference<T> createCtTypeReference​(java.lang.Class<?> originalClass)
        Creates a type reference.
        Type Parameters:
        T - Type of the reference.
        Parameters:
        originalClass - Original class of the reference.
        Returns:
        a type reference.
      • createCtPackageReference

        public CtPackageReference createCtPackageReference​(java.lang.Package originalPackage)
        Creates a package reference.
        Parameters:
        originalPackage - Original package of the reference.
        Returns:
        a package reference.
      • createAnnotation

        public <A extends java.lang.annotation.Annotation> CtAnnotation<A> createAnnotation​(CtTypeReference<A> annotationType)
        Creates an annotation.
        Parameters:
        annotationType - Type of the annotation.
        Returns:
        an annotation.
      • getReferences

        public <R extends CtReference,​E extends CtNamedElement> java.util.List<R> getReferences​(java.util.List<E> elements)
        Gets a list of references from a list of elements.
        Type Parameters:
        R - the expected reference type
        E - the element type
        Parameters:
        elements - the element list
        Returns:
        the corresponding list of references
      • modifiers

        public java.util.Set<ModifierKind> modifiers​(ModifierKind... modifiers)
        Creates a modifier set.
        Parameters:
        modifiers - to put in set
        Returns:
        Set of given modifiers
      • createCodeSnippetExpression

        public <T> CtCodeSnippetExpression<T> createCodeSnippetExpression​(java.lang.String expression)
        Creates a Code Snippet expression.
        Type Parameters:
        T - The type of the expression represented by the CodeSnippet
        Parameters:
        expression - The string that contains the expression.
        Returns:
        a new CtCodeSnippetExpression.
      • createCodeSnippetStatement

        public CtCodeSnippetStatement createCodeSnippetStatement​(java.lang.String statement)
        Creates a Code Snippet statement.
        Parameters:
        statement - The String containing the statement.
        Returns:
        a new CtCodeSnippetStatement
      • createComment

        public CtComment createComment​(java.lang.String content,
                                       CtComment.CommentType type)
        Creates a comment
        Parameters:
        content - The content of the comment
        type - The comment type
        Returns:
        a new CtComment
      • createInlineComment

        public CtComment createInlineComment​(java.lang.String content)
        Creates an inline comment
        Parameters:
        content - The content of the comment
        Returns:
        a new CtComment
      • createJavaDocTag

        public CtJavaDocTag createJavaDocTag​(java.lang.String content,
                                             CtJavaDocTag.TagType type)
        Creates a javadoc tag
        Parameters:
        content - The content of the javadoc tag with a possible paramater
        type - The tag type
        Returns:
        a new CtJavaDocTag
      • createJavaDocTag

        public CtJavaDocTag createJavaDocTag​(java.lang.String content,
                                             CtJavaDocTag.TagType type,
                                             java.lang.String realName)
        Creates a javadoc tag
        Parameters:
        content - The content of the javadoc tag with a possible paramater
        type - The tag type
        realName - The real name of the tag
        Returns:
        a new CtJavaDocTag