Package spoon.reflect.factory

Interface Factory

All Known Implementing Classes:

FactoryImpl

public interface Factory

Provides the sub-factories required by Spoon. Most classes provides a method getFactory() that returns the current factory. Otherwise FactoryImpl is a default implementation.

Method Summary

Modifier and Type	Method	Description
AnnotationFactory	Annotation()	Access to AnnotationFactory subfactory
ClassFactory	Class()	Access to ClassFactory subfactory
CodeFactory	Code()	Access to CodeFactory subfactory
CompilationUnitFactory	CompilationUnit()	Access to CompilationUnitFactory subfactory
ConstructorFactory	Constructor()	Access to ConstructorFactory subfactory
CoreFactory	Core()	Access to CoreFactory subfactory
<A extends Annotation> CtAnnotation<A>	createAnnotation()
<A extends Annotation> CtAnnotation<A>	createAnnotation(CtTypeReference<A> annotationType)
<T> CtAnnotationFieldAccess<T>	createAnnotationFieldAccess()
<T> CtAnnotationMethod<T>	createAnnotationMethod()
<T extends Annotation> CtAnnotationType<T>	createAnnotationType()
CtAnnotationType	createAnnotationType(String qualifiedName)
CtAnnotationType	createAnnotationType(CtPackage owner, String simpleName)
CtAnonymousExecutable	createAnonymous(CtClass<?> target, CtBlock<Void> body)
CtAnonymousExecutable	createAnonymousExecutable()
<T> CtArrayRead<T>	createArrayRead()
<T> CtArrayTypeReference<T>	createArrayReference(String qualifiedName)
<T> CtArrayTypeReference<T[]>	createArrayReference(CtType<T> type)
CtArrayTypeReference<?>	createArrayReference(CtTypeReference<?> reference, int n)
<T> CtArrayTypeReference<T[]>	createArrayReference(CtTypeReference<T> reference)
<T> CtArrayTypeReference<T>	createArrayTypeReference()
<T> CtArrayWrite<T>	createArrayWrite()
<T> CtAssert<T>	createAssert()
<T,A extends T> CtAssignment<T,A>	createAssignment()
<T> CtBinaryOperator<T>	createBinaryOperator()
<T> CtBinaryOperator<T>	createBinaryOperator(CtExpression<?> left, CtExpression<?> right, BinaryOperatorKind kind)
<R> CtBlock<R>	createBlock()
BodyHolderSourcePosition	createBodyHolderSourcePosition(CompilationUnit compilationUnit, int startSource, int end, int modifierStart, int modifierEnd, int declarationStart, int declarationEnd, int bodyStart, int bodyEnd, int[] lineSeparatorPositions)
CtBreak	createBreak()
<S> CtCase<S>	createCase()
CtCatch	createCatch()
<T> CtCatchVariable<T>	createCatchVariable()
<T> CtCatchVariable<T>	createCatchVariable(CtTypeReference<T> type, String name, ModifierKind... modifierKinds)
<T> CtCatchVariableReference<T>	createCatchVariableReference()
<T> CtCatchVariableReference<T>	createCatchVariableReference(CtCatchVariable<T> catchVariable)
<T> CtClass<T>	createClass()
CtClass	createClass(String qualifiedName)
CtClass	createClass(CtClass<?> declaringClass, String simpleName)
CtClass	createClass(CtPackage owner, String simpleName)
<T> CtFieldAccess<Class<T>>	createClassAccess(CtTypeReference<T> type)
<T> CtCodeSnippetExpression<T>	createCodeSnippetExpression()
<T> CtCodeSnippetExpression<T>	createCodeSnippetExpression(String expression)
CtCodeSnippetStatement	createCodeSnippetStatement()
CtCodeSnippetStatement	createCodeSnippetStatement(String statement)
CtComment	createComment()
CtComment	createComment(String content, CtComment.CommentType type)
CompilationUnit	createCompilationUnit()
<T> CtConditional<T>	createConditional()
<T> CtConstructor<T>	createConstructor()
CtConstructor	createConstructor(CtClass target, Set<ModifierKind> modifiers, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes)
CtConstructor	createConstructor(CtClass target, Set<ModifierKind> modifiers, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes, CtBlock body)
CtConstructor	createConstructor(CtClass target, CtConstructor<?> source)
CtConstructor	createConstructor(CtClass target, CtMethod<?> source)
<T> CtConstructorCall<T>	createConstructorCall()
<T> CtConstructorCall<T>	createConstructorCall(CtTypeReference<T> type, CtExpression<?>... parameters)
CtContinue	createContinue()
<T extends CtStatement> CtBlock<?>	createCtBlock(T element)
CtCatch	createCtCatch(String nameCatch, Class<? extends Throwable> exception, CtBlock<?> ctBlock)
<T> CtField<T>	createCtField(String name, CtTypeReference<T> type, String exp, ModifierKind... visibilities)
CtPackageReference	createCtPackageReference(Package originalPackage)
CtThrow	createCtThrow(String thrownExp)
<T> CtTypeReference<T>	createCtTypeReference(Class<?> originalClass)
DeclarationSourcePosition	createDeclarationSourcePosition(CompilationUnit compilationUnit, int startSource, int end, int modifierStart, int modifierEnd, int declarationStart, int declarationEnd, int[] lineSeparatorPositions)
<T> CtConstructor<T>	createDefault(CtClass<T> target)
CtDo	createDo()
CtElement	createElement(Class<? extends CtElement> klass)
<T extends Enum<?>> CtEnum<T>	createEnum()
CtEnum<?>	createEnum(String qualifiedName)
CtEnum<?>	createEnum(CtPackage owner, String simpleName)
<T> CtEnumValue<T>	createEnumValue()
<T> CtExecutableReference<T>	createExecutableReference()
<T,E extends CtExpression<?>> CtExecutableReferenceExpression<T,E>	createExecutableReferenceExpression()
<T> CtField<T>	createField()
CtField	createField(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference type, String name)
CtField	createField(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference type, String name, CtExpression defaultExpression)
CtField	createField(CtType<?> target, CtField source)
<T> CtFieldRead<T>	createFieldRead()
<T> CtFieldReference<T>	createFieldReference()
<T> CtFieldWrite<T>	createFieldWrite()
CtFor	createFor()
CtForEach	createForEach()
CtIf	createIf()
CtImport	createImport(CtReference reference)
CtComment	createInlineComment(String content)
<T> CtInterface<T>	createInterface()
CtInterface	createInterface(String qualifiedName)
CtInterface	createInterface(CtPackage owner, String simpleName)
CtInterface	createInterface(CtType owner, String simpleName)
<T> CtIntersectionTypeReference<T>	createIntersectionTypeReference()
<T> CtIntersectionTypeReference<T>	createIntersectionTypeReferenceWithBounds(List<CtTypeReference<?>> bounds)
<T> CtConstructor<T>	createInvisibleArrayConstructor()
<T> CtInvocation<T>	createInvocation()
<T> CtInvocation<T>	createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, List<CtExpression<?>> arguments)
<T> CtInvocation<T>	createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, CtExpression<?>... arguments)
CtJavaDoc	createJavaDoc()
CtJavaDocTag	createJavaDocTag()
CtJavaDocTag	createJavaDocTag(String content, CtJavaDocTag.TagType type)
CtJavaDocTag	createJavaDocTag(String content, CtJavaDocTag.TagType type, String realName)
<T> CtLambda<T>	createLambda()
<T> CtLiteral<T>	createLiteral()
<T> CtLiteral<T>	createLiteral(T value)
<T> CtNewArray<T[]>	createLiteralArray(T[] value)
<T> CtLocalVariable<T>	createLocalVariable()
<T> CtLocalVariable<T>	createLocalVariable(CtTypeReference<T> type, String name, CtExpression<T> defaultExpression)
<T> CtLocalVariableReference<T>	createLocalVariableReference()
<T> CtLocalVariableReference<T>	createLocalVariableReference(CtLocalVariable<T> localVariable)
<T> CtLocalVariableReference<T>	createLocalVariableReference(CtTypeReference<T> type, String name)
<T> CtMethod<T>	createMethod()
CtMethod	createMethod(CtClass<?> target, Set<ModifierKind> modifiers, CtTypeReference returnType, String name, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes, CtBlock body)
CtMethod	createMethod(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference returnType, String name, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes)
CtMethod	createMethod(CtType<?> target, CtMethod source, boolean redirectReferences)
CtModule	createModule(String moduleName)
CtModuleReference	createModuleReference(CtModule ctModule)
CtModuleRequirement	createModuleRequirement(CtModuleReference ctModuleReference)
<T> CtNewArray<T>	createNewArray()
<T> CtNewClass<T>	createNewClass()
CtNewClass<?>	createNewClass(CtType<?> superClass, CtExpression<?>... parameters)	Creates an anonymous class
<T,A extends T> CtOperatorAssignment<T,A>	createOperatorAssignment()
CtPackage	createPackage()
CtPackage	createPackage(CtPackage parent, String simpleName)
CtPackageDeclaration	createPackageDeclaration(CtPackageReference packageRef)
CtPackageExport	createPackageExport(CtPackageReference ctPackageReference)
CtPackageReference	createPackageReference()
<T> CtParameter<T>	createParameter()
<T> CtParameter<T>	createParameter(CtExecutable<?> parent, CtTypeReference<T> type, String name)
<T> CtParameterReference<T>	createParameterReference()
<T> CtParameterReference<T>	createParameterReference(CtParameter<T> parameter)
PartialEvaluator	createPartialEvaluator()
SourcePosition	createPartialSourcePosition(CompilationUnit compilationUnit)
CtProvidedService	createProvidedService(CtTypeReference ctTypeReference)
CtQuery	createQuery()
CtQuery	createQuery(Iterable<?> input)
CtQuery	createQuery(Object input)
CtQuery	createQuery(Object... input)
<T> CtTypeReference<T>	createReference(String qualifiedName)
List<CtTypeReference<?>>	createReferences(List<Class<?>> classes)
<R> CtReturn<R>	createReturn()
<T> CtTypeReference<T>	createSimplyQualifiedReference(String qualifiedName)
SourcePosition	createSourcePosition(CompilationUnit compilationUnit, int startSource, int end, int[] lineSeparatorPositions)
<R> CtStatementList	createStatementList()
<R> CtStatementList	createStatementList(CtBlock<R> block)
<T> CtSuperAccess<T>	createSuperAccess()
<S> CtSwitch<S>	createSwitch()
<T,S> CtSwitchExpression<T,S>	createSwitchExpression()
CtSynchronized	createSynchronized()
CtTextBlock	createTextBlock()
CtTextBlock	createTextBlock(String value)
<T> CtThisAccess<T>	createThisAccess()
<T> CtThisAccess<T>	createThisAccess(CtTypeReference<T> type)
<T> CtThisAccess<T>	createThisAccess(CtTypeReference<T> type, boolean isImplicit)
CtThrow	createThrow()
CtTry	createTry()
CtTryWithResource	createTryWithResource()
<T> CtTypeAccess<T>	createTypeAccess()
<T> CtTypeAccess<T>	createTypeAccess(CtTypeReference<T> accessedType)
<T> CtTypeAccess<T>	createTypeAccess(CtTypeReference<T> accessedType, boolean isImplicit)
<T> CtTypeAccess<T>	createTypeAccessWithoutCloningReference(CtTypeReference<T> accessedType)
GenericTypeAdapter	createTypeAdapter(CtFormalTypeDeclarer formalTypeDeclarer)
CtTypeMemberWildcardImportReference	createTypeMemberWildcardImportReference(CtTypeReference<?> typeReference)
CtTypeParameter	createTypeParameter()
CtTypeParameterReference	createTypeParameterReference()
CtTypeParameterReference	createTypeParameterReference(String name)
<T> CtTypeReference<T>	createTypeReference()
<T> CtUnaryOperator<T>	createUnaryOperator()
<T> CtUnboundVariableReference<T>	createUnboundVariableReference()
CtImport	createUnresolvedImport(String reference, boolean isStatic)
CtUsedService	createUsedService(CtTypeReference typeReference)
<A,T extends A> CtAssignment<A,T>	createVariableAssignment(CtVariableReference<A> variable, boolean isStatic, CtExpression<T> expression)
<T> CtStatementList	createVariableAssignments(List<? extends CtVariable<T>> variables, List<? extends CtExpression<T>> expressions)
<T> CtVariableRead<T>	createVariableRead()
<T> CtVariableAccess<T>	createVariableRead(CtVariableReference<T> variable, boolean isStatic)
List<CtExpression<?>>	createVariableReads(List<? extends CtVariable<?>> variables)
<T> CtVariableWrite<T>	createVariableWrite()
<T> CtVariableAccess<T>	createVariableWrite(CtVariableReference<T> variable, boolean isStatic)
CtWhile	createWhile()
CtWildcardReference	createWildcardReference()
CtYieldStatement	createYieldStatement(boolean isImplicit)
EnumFactory	Enum()	Access to EnumFactory subfactory
EvalFactory	Eval()	Access to EvalFactory subfactory
ExecutableFactory	Executable()	Access to ExecutableFactory subfactory
FieldFactory	Field()	Access to FieldFactory subfactory
Environment	getEnvironment()	Access to the Environment
CtModel	getModel()	returns the Spoon model that has been built with this factory or one of its subfactories
InterfaceFactory	Interface()	Access to InterfaceFactory subfactory
MethodFactory	Method()	Access to MethodFactory subfactory
ModuleFactory	Module()	Access to ModuleFactory subfactory for Java 9 modules
PackageFactory	Package()	Access to PackageFactory subfactory
QueryFactory	Query()	Access to QueryFactory subfactory
Factory	Templates()	Access to templates
TypeFactory	Type()	Access to TypeFactory subfactory

Method Detail

getModel

CtModel getModel()

returns the Spoon model that has been built with this factory or one of its subfactories

Core

CoreFactory Core()

Access to CoreFactory subfactory

Type

TypeFactory Type()

Access to TypeFactory subfactory

Enum

EnumFactory Enum()

Access to EnumFactory subfactory

getEnvironment

Environment getEnvironment()

Access to the Environment

Package

PackageFactory Package()

Access to PackageFactory subfactory

Code

CodeFactory Code()

Access to CodeFactory subfactory

Class

ClassFactory Class()

Access to ClassFactory subfactory

Field

FieldFactory Field()

Access to FieldFactory subfactory

Executable

ExecutableFactory Executable()

Access to ExecutableFactory subfactory

CompilationUnit

CompilationUnitFactory CompilationUnit()

Access to CompilationUnitFactory subfactory

Interface

InterfaceFactory Interface()

Access to InterfaceFactory subfactory

Method

MethodFactory Method()

Access to MethodFactory subfactory

Annotation

AnnotationFactory Annotation()

Access to AnnotationFactory subfactory

Eval

EvalFactory Eval()

Access to EvalFactory subfactory

Constructor

ConstructorFactory Constructor()

Access to ConstructorFactory subfactory

Query

QueryFactory Query()

Access to QueryFactory subfactory

Module

ModuleFactory Module()

Access to ModuleFactory subfactory for Java 9 modules

Templates

Factory Templates()

Access to templates

createAnnotation

<A extends Annotation> CtAnnotation<A> createAnnotation(CtTypeReference<A> annotationType)

See Also:

CodeFactory.createAnnotation(CtTypeReference)

createVariableAssignment

<A,T extends A> CtAssignment<A,T> createVariableAssignment(CtVariableReference<A> variable,
                                                                       boolean isStatic,
                                                                       CtExpression<T> expression)

See Also:

CodeFactory.createVariableAssignment(CtVariableReference,boolean, CtExpression)

createStatementList

<R> CtStatementList createStatementList(CtBlock<R> block)

See Also:

CodeFactory.createStatementList(CtBlock)

createCtBlock

<T extends CtStatement> CtBlock<?> createCtBlock(T element)

See Also:

CodeFactory.createCtBlock(CtStatement)

createBinaryOperator

<T> CtBinaryOperator<T> createBinaryOperator(CtExpression<?> left,
                                             CtExpression<?> right,
                                             BinaryOperatorKind kind)

See Also:

CodeFactory.createBinaryOperator(CtExpression,CtExpression, BinaryOperatorKind)

createCatchVariable

<T> CtCatchVariable<T> createCatchVariable(CtTypeReference<T> type,
                                           String name,
                                           ModifierKind... modifierKinds)

See Also:

CodeFactory.createCatchVariable(CtTypeReference,String, ModifierKind[])

createCodeSnippetExpression

<T> CtCodeSnippetExpression<T> createCodeSnippetExpression(String expression)

See Also:

CodeFactory.createCodeSnippetExpression(String)

createConstructorCall

<T> CtConstructorCall<T> createConstructorCall(CtTypeReference<T> type,
                                               CtExpression<?>... parameters)

See Also:

CodeFactory.createConstructorCall(CtTypeReference,CtExpression[])

createClassAccess

<T> CtFieldAccess<Class<T>> createClassAccess(CtTypeReference<T> type)

See Also:

CodeFactory.createClassAccess(CtTypeReference)

createInvocation

<T> CtInvocation<T> createInvocation(CtExpression<?> target,
                                     CtExecutableReference<T> executable,
                                     List<CtExpression<?>> arguments)

See Also:

CodeFactory.createInvocation(CtExpression, CtExecutableReference, List)

createInvocation

<T> CtInvocation<T> createInvocation(CtExpression<?> target,
                                     CtExecutableReference<T> executable,
                                     CtExpression<?>... arguments)

See Also:

CodeFactory.createInvocation(CtExpression,CtExecutableReference,CtExpression[])

createLiteral

<T> CtLiteral<T> createLiteral(T value)

See Also:

CodeFactory.createLiteral(Object)

createLocalVariable

<T> CtLocalVariable<T> createLocalVariable(CtTypeReference<T> type,
                                           String name,
                                           CtExpression<T> defaultExpression)

See Also:

CodeFactory.createLocalVariable(CtTypeReference,String,CtExpression)

createLiteralArray

<T> CtNewArray<T[]> createLiteralArray(T[] value)

See Also:

CodeFactory.createLiteralArray(Object[])

createNewClass

CtNewClass<?> createNewClass(CtType<?> superClass,
                             CtExpression<?>... parameters)

Creates an anonymous class

Parameters:

superClass - Anonymous class in the new class.

parameters - the arguments of the constructor call.

createVariableAssignments

<T> CtStatementList createVariableAssignments(List<? extends CtVariable<T>> variables,
                                              List<? extends CtExpression<T>> expressions)

See Also:

CodeFactory.createVariableAssignments(List,List)

createThisAccess

<T> CtThisAccess<T> createThisAccess(CtTypeReference<T> type)

See Also:

CodeFactory.createThisAccess(CtTypeReference)

createThisAccess

<T> CtThisAccess<T> createThisAccess(CtTypeReference<T> type,
                                     boolean isImplicit)

See Also:

CodeFactory.createThisAccess(CtTypeReference,boolean)

createTypeAccess

<T> CtTypeAccess<T> createTypeAccess(CtTypeReference<T> accessedType)

See Also:

CodeFactory.createTypeAccess(CtTypeReference)

createTypeAccess

<T> CtTypeAccess<T> createTypeAccess(CtTypeReference<T> accessedType,
                                     boolean isImplicit)

See Also:

CodeFactory.createTypeAccess(CtTypeReference,boolean)

createTypeAccessWithoutCloningReference

<T> CtTypeAccess<T> createTypeAccessWithoutCloningReference(CtTypeReference<T> accessedType)

See Also:

CodeFactory.createTypeAccessWithoutCloningReference(CtTypeReference)

createVariableRead

<T> CtVariableAccess<T> createVariableRead(CtVariableReference<T> variable,
                                           boolean isStatic)

See Also:

CodeFactory.createVariableRead(CtVariableReference,boolean)

createVariableWrite

<T> CtVariableAccess<T> createVariableWrite(CtVariableReference<T> variable,
                                            boolean isStatic)

See Also:

CodeFactory.createVariableWrite(CtVariableReference,boolean)

createCtField

<T> CtField<T> createCtField(String name,
                             CtTypeReference<T> type,
                             String exp,
                             ModifierKind... visibilities)

See Also:

CodeFactory.createCtField(String,CtTypeReference,String,ModifierKind[])

createCatchVariableReference

<T> CtCatchVariableReference<T> createCatchVariableReference(CtCatchVariable<T> catchVariable)

See Also:

CodeFactory.createCatchVariableReference(CtCatchVariable)

createLocalVariableReference

<T> CtLocalVariableReference<T> createLocalVariableReference(CtLocalVariable<T> localVariable)

See Also:

CodeFactory.createLocalVariableReference(CtLocalVariable)

createLocalVariableReference

<T> CtLocalVariableReference<T> createLocalVariableReference(CtTypeReference<T> type,
                                                             String name)

See Also:

CodeFactory.createLocalVariableReference(CtTypeReference,String)

createCtTypeReference

<T> CtTypeReference<T> createCtTypeReference(Class<?> originalClass)

See Also:

CodeFactory.createCtTypeReference(Class)

createVariableReads

List<CtExpression<?>> createVariableReads(List<? extends CtVariable<?>> variables)

See Also:

CodeFactory.createVariableReads(List)

createCtCatch

CtCatch createCtCatch(String nameCatch,
                      Class<? extends Throwable> exception,
                      CtBlock<?> ctBlock)

See Also:

CodeFactory.createCtCatch(String,Class,CtBlock)

createCodeSnippetStatement

CtCodeSnippetStatement createCodeSnippetStatement(String statement)

See Also:

CodeFactory.createCodeSnippetStatement(String)

createComment

CtComment createComment(String content,
                        CtComment.CommentType type)

See Also:

CodeFactory.createComment(String,CtComment.CommentType)

createJavaDocTag

CtJavaDocTag createJavaDocTag(String content,
                              CtJavaDocTag.TagType type)

See Also:

CodeFactory.createJavaDocTag(String,CtJavaDocTag.TagType)

createJavaDocTag

CtJavaDocTag createJavaDocTag(String content,
                              CtJavaDocTag.TagType type,
                              String realName)

See Also:

CodeFactory.createJavaDocTag(String,CtJavaDocTag.TagType,String)

createJavaDoc

CtJavaDoc createJavaDoc()

See Also:

CoreFactory.createJavaDoc()

createJavaDocTag

CtJavaDocTag createJavaDocTag()

See Also:

CodeFactory#createJavaDocTag()

createInlineComment

CtComment createInlineComment(String content)

See Also:

CodeFactory.createInlineComment(String)

createCtThrow

CtThrow createCtThrow(String thrownExp)

See Also:

CodeFactory.createCtThrow(String)

createCtPackageReference

CtPackageReference createCtPackageReference(Package originalPackage)

See Also:

CodeFactory.createCtPackageReference(Package)

createDefault

<T> CtConstructor<T> createDefault(CtClass<T> target)

See Also:

ConstructorFactory.createDefault(CtClass)

createAnnotation

<A extends Annotation> CtAnnotation<A> createAnnotation()

See Also:

CoreFactory.createAnnotation()

createBlock

<R> CtBlock<R> createBlock()

See Also:

CoreFactory.createBlock()

createReturn

<R> CtReturn<R> createReturn()

See Also:

CoreFactory.createReturn()

createStatementList

<R> CtStatementList createStatementList()

See Also:

CoreFactory.createStatementList()

createCase

<S> CtCase<S> createCase()

See Also:

CoreFactory.createCase()

createSwitch

<S> CtSwitch<S> createSwitch()

See Also:

CoreFactory.createSwitch()

createSwitchExpression

<T,S> CtSwitchExpression<T,S> createSwitchExpression()

See Also:

CoreFactory.createSwitchExpression()

createEnum

<T extends Enum<?>> CtEnum<T> createEnum()

See Also:

CoreFactory.createEnum()

createAnnotationType

<T extends Annotation> CtAnnotationType<T> createAnnotationType()

See Also:

CoreFactory.createAnnotationType()

createAssignment

<T,A extends T> CtAssignment<T,A> createAssignment()

See Also:

CoreFactory.createAssignment()

createOperatorAssignment

<T,A extends T> CtOperatorAssignment<T,A> createOperatorAssignment()

See Also:

CoreFactory.createOperatorAssignment()

createExecutableReferenceExpression

<T,E extends CtExpression<?>> CtExecutableReferenceExpression<T,E> createExecutableReferenceExpression()

See Also:

CoreFactory.createExecutableReferenceExpression()

createAnnotationFieldAccess

<T> CtAnnotationFieldAccess<T> createAnnotationFieldAccess()

See Also:

CoreFactory.createAnnotationFieldAccess()

createArrayRead

<T> CtArrayRead<T> createArrayRead()

See Also:

CoreFactory.createArrayRead()

createArrayWrite

<T> CtArrayWrite<T> createArrayWrite()

See Also:

CoreFactory.createArrayWrite()

createAssert

<T> CtAssert<T> createAssert()

See Also:

CoreFactory.createAssert()

createBinaryOperator

<T> CtBinaryOperator<T> createBinaryOperator()

See Also:

CoreFactory.createBinaryOperator()

createCatchVariable

<T> CtCatchVariable<T> createCatchVariable()

See Also:

CoreFactory.createCatchVariable()

createCodeSnippetExpression

<T> CtCodeSnippetExpression<T> createCodeSnippetExpression()

See Also:

CoreFactory.createCodeSnippetExpression()

createConditional

<T> CtConditional<T> createConditional()

See Also:

CoreFactory.createConditional()

createConstructorCall

<T> CtConstructorCall<T> createConstructorCall()

See Also:

CoreFactory.createConstructorCall()

createFieldRead

<T> CtFieldRead<T> createFieldRead()

See Also:

CoreFactory.createFieldRead()

createFieldWrite

<T> CtFieldWrite<T> createFieldWrite()

See Also:

CoreFactory.createFieldWrite()

createInvocation

<T> CtInvocation<T> createInvocation()

See Also:

CoreFactory.createInvocation()

createLambda

<T> CtLambda<T> createLambda()

See Also:

CoreFactory.createLambda()

createLiteral

<T> CtLiteral<T> createLiteral()

See Also:

CoreFactory.createLiteral()

createTextBlock

CtTextBlock createTextBlock()

See Also:

CoreFactory.createTextBlock()

createTextBlock

CtTextBlock createTextBlock(String value)

See Also:

CodeFactory.createTextBlock(String)

createLocalVariable

<T> CtLocalVariable<T> createLocalVariable()

See Also:

CoreFactory.createLocalVariable()

createNewArray

<T> CtNewArray<T> createNewArray()

See Also:

CoreFactory.createNewArray()

createNewClass

<T> CtNewClass<T> createNewClass()

See Also:

CoreFactory.createNewClass()

createSuperAccess

<T> CtSuperAccess<T> createSuperAccess()

See Also:

CoreFactory.createSuperAccess()

createThisAccess

<T> CtThisAccess<T> createThisAccess()

See Also:

CoreFactory.createThisAccess()

createTypeAccess

<T> CtTypeAccess<T> createTypeAccess()

See Also:

CoreFactory.createTypeAccess()

createUnaryOperator

<T> CtUnaryOperator<T> createUnaryOperator()

See Also:

CoreFactory.createUnaryOperator()

createVariableRead

<T> CtVariableRead<T> createVariableRead()

See Also:

CoreFactory.createVariableRead()

createVariableWrite

<T> CtVariableWrite<T> createVariableWrite()

See Also:

CoreFactory.createVariableWrite()

createAnnotationMethod

<T> CtAnnotationMethod<T> createAnnotationMethod()

See Also:

CoreFactory.createAnnotationMethod()

createClass

<T> CtClass<T> createClass()

See Also:

CoreFactory.createClass()

createConstructor

<T> CtConstructor<T> createConstructor()

See Also:

CoreFactory.createConstructor()

createInvisibleArrayConstructor

<T> CtConstructor<T> createInvisibleArrayConstructor()

See Also:

()

createEnumValue

<T> CtEnumValue<T> createEnumValue()

See Also:

CoreFactory.createEnumValue()

createField

<T> CtField<T> createField()

See Also:

CoreFactory.createField()

createInterface

<T> CtInterface<T> createInterface()

See Also:

CoreFactory.createInterface()

createMethod

<T> CtMethod<T> createMethod()

See Also:

CoreFactory.createMethod()

createParameter

<T> CtParameter<T> createParameter()

See Also:

CoreFactory.createParameter()

createArrayTypeReference

<T> CtArrayTypeReference<T> createArrayTypeReference()

See Also:

CoreFactory.createArrayTypeReference()

createCatchVariableReference

<T> CtCatchVariableReference<T> createCatchVariableReference()

See Also:

CoreFactory.createCatchVariableReference()

createExecutableReference

<T> CtExecutableReference<T> createExecutableReference()

See Also:

CoreFactory.createExecutableReference()

createFieldReference

<T> CtFieldReference<T> createFieldReference()

See Also:

CoreFactory.createFieldReference()

createIntersectionTypeReference

<T> CtIntersectionTypeReference<T> createIntersectionTypeReference()

See Also:

CoreFactory.createIntersectionTypeReference()

createLocalVariableReference

<T> CtLocalVariableReference<T> createLocalVariableReference()

See Also:

CoreFactory.createLocalVariableReference()

createParameterReference

<T> CtParameterReference<T> createParameterReference()

See Also:

CoreFactory.createParameterReference()

createTypeReference

<T> CtTypeReference<T> createTypeReference()

See Also:

CoreFactory.createTypeReference()

createUnboundVariableReference

<T> CtUnboundVariableReference<T> createUnboundVariableReference()

See Also:

CoreFactory.createUnboundVariableReference()

createBreak

CtBreak createBreak()

See Also:

CoreFactory.createBreak()

createCatch

CtCatch createCatch()

See Also:

CoreFactory.createCatch()

createCodeSnippetStatement

CtCodeSnippetStatement createCodeSnippetStatement()

See Also:

CoreFactory.createCodeSnippetStatement()

createComment

CtComment createComment()

See Also:

CoreFactory.createComment()

createContinue

CtContinue createContinue()

See Also:

CoreFactory.createContinue()

createDo

CtDo createDo()

See Also:

CoreFactory.createDo()

createFor

CtFor createFor()

See Also:

CoreFactory.createFor()

createForEach

CtForEach createForEach()

See Also:

CoreFactory.createForEach()

createIf

CtIf createIf()

See Also:

CoreFactory.createIf()

createSynchronized

CtSynchronized createSynchronized()

See Also:

CoreFactory.createSynchronized()

createThrow

CtThrow createThrow()

See Also:

CoreFactory.createThrow()

createTry

CtTry createTry()

See Also:

CoreFactory.createTry()

createTryWithResource

CtTryWithResource createTryWithResource()

See Also:

CoreFactory.createTryWithResource()

createWhile

CtWhile createWhile()

See Also:

CoreFactory.createWhile()

createCompilationUnit

CompilationUnit createCompilationUnit()

See Also:

CoreFactory.createCompilationUnit()

createSourcePosition

SourcePosition createSourcePosition(CompilationUnit compilationUnit,
                                    int startSource,
                                    int end,
                                    int[] lineSeparatorPositions)

See Also:

CoreFactory.createSourcePosition(CompilationUnit,int,int,int[])

createBodyHolderSourcePosition

BodyHolderSourcePosition createBodyHolderSourcePosition(CompilationUnit compilationUnit,
                                                        int startSource,
                                                        int end,
                                                        int modifierStart,
                                                        int modifierEnd,
                                                        int declarationStart,
                                                        int declarationEnd,
                                                        int bodyStart,
                                                        int bodyEnd,
                                                        int[] lineSeparatorPositions)

See Also:

CoreFactory.createBodyHolderSourcePosition(CompilationUnit,int,int,int,int,int,int,int,int,int[])

createDeclarationSourcePosition

DeclarationSourcePosition createDeclarationSourcePosition(CompilationUnit compilationUnit,
                                                          int startSource,
                                                          int end,
                                                          int modifierStart,
                                                          int modifierEnd,
                                                          int declarationStart,
                                                          int declarationEnd,
                                                          int[] lineSeparatorPositions)

See Also:

CoreFactory.createDeclarationSourcePosition(CompilationUnit,int,int,int,int,int,int,int[])

createAnonymousExecutable

CtAnonymousExecutable createAnonymousExecutable()

See Also:

CoreFactory.createAnonymousExecutable()

createPackage

CtPackage createPackage()

See Also:

CoreFactory.createPackage()

createTypeParameter

CtTypeParameter createTypeParameter()

See Also:

CoreFactory.createTypeParameter()

createPackageReference

CtPackageReference createPackageReference()

See Also:

CoreFactory.createPackageReference()

createTypeParameterReference

CtTypeParameterReference createTypeParameterReference()

See Also:

CoreFactory.createTypeParameterReference()

createWildcardReference

CtWildcardReference createWildcardReference()

See Also:

CoreFactory.createWildcardReference()

createPartialEvaluator

PartialEvaluator createPartialEvaluator()

See Also:

EvalFactory.createPartialEvaluator()

createParameter

<T> CtParameter<T> createParameter(CtExecutable<?> parent,
                                   CtTypeReference<T> type,
                                   String name)

See Also:

ExecutableFactory.createParameter(CtExecutable,CtTypeReference,String)

createParameterReference

<T> CtParameterReference<T> createParameterReference(CtParameter<T> parameter)

See Also:

ExecutableFactory.createParameterReference(CtParameter)

createAnonymous

CtAnonymousExecutable createAnonymous(CtClass<?> target,
                                      CtBlock<Void> body)

See Also:

ExecutableFactory.createAnonymous(CtClass,CtBlock)

createArrayReference

<T> CtArrayTypeReference<T> createArrayReference(String qualifiedName)

See Also:

TypeFactory.createArrayReference(String)

createArrayReference

<T> CtArrayTypeReference<T[]> createArrayReference(CtType<T> type)

See Also:

TypeFactory.createArrayReference(CtType)

createArrayReference

<T> CtArrayTypeReference<T[]> createArrayReference(CtTypeReference<T> reference)

See Also:

TypeFactory.createArrayReference(CtTypeReference)

createIntersectionTypeReferenceWithBounds

<T> CtIntersectionTypeReference<T> createIntersectionTypeReferenceWithBounds(List<CtTypeReference<?>> bounds)

See Also:

TypeFactory.createIntersectionTypeReferenceWithBounds(List)

createTypeAdapter

GenericTypeAdapter createTypeAdapter(CtFormalTypeDeclarer formalTypeDeclarer)

See Also:

TypeFactory.createTypeAdapter(CtFormalTypeDeclarer)

createReferences

List<CtTypeReference<?>> createReferences(List<Class<?>> classes)

See Also:

TypeFactory.createReferences(List)

createArrayReference

CtArrayTypeReference<?> createArrayReference(CtTypeReference<?> reference,
                                             int n)

See Also:

TypeFactory.createArrayReference(CtTypeReference,int)

createTypeParameterReference

CtTypeParameterReference createTypeParameterReference(String name)

See Also:

TypeFactory.createTypeParameterReference(String)

createQuery

CtQuery createQuery()

See Also:

QueryFactory.createQuery()

createQuery

CtQuery createQuery(Object input)

See Also:

QueryFactory.createQuery(Object)

createQuery

CtQuery createQuery(Object... input)

See Also:

QueryFactory.createQuery(Object...)

createQuery

CtQuery createQuery(Iterable<?> input)

See Also:

QueryFactory.createQuery(Iterable)

createAnnotationType

CtAnnotationType createAnnotationType(String qualifiedName)

See Also:

AnnotationFactory.create(String)

createAnnotationType

CtAnnotationType createAnnotationType(CtPackage owner,
                                      String simpleName)

See Also:

AnnotationFactory.create(CtPackage, String)

createClass

CtClass createClass(String qualifiedName)

See Also:

ClassFactory.create(String)

createClass

CtClass createClass(CtClass<?> declaringClass,
                    String simpleName)

See Also:

ClassFactory.create(CtClass, String)

createClass

CtClass createClass(CtPackage owner,
                    String simpleName)

See Also:

ClassFactory.create(CtPackage, String)

createConstructor

CtConstructor createConstructor(CtClass target,
                                CtConstructor<?> source)

See Also:

ConstructorFactory.create(CtClass, CtConstructor)

createConstructor

CtConstructor createConstructor(CtClass target,
                                CtMethod<?> source)

See Also:

ConstructorFactory.create(CtClass, CtMethod)

createConstructor

CtConstructor createConstructor(CtClass target,
                                Set<ModifierKind> modifiers,
                                List<CtParameter<?>> parameters,
                                Set<CtTypeReference<? extends Throwable>> thrownTypes)

See Also:

ConstructorFactory.create(CtClass, Set, List, Set)

createConstructor

CtConstructor createConstructor(CtClass target,
                                Set<ModifierKind> modifiers,
                                List<CtParameter<?>> parameters,
                                Set<CtTypeReference<? extends Throwable>> thrownTypes,
                                CtBlock body)

See Also:

ConstructorFactory.create(CtClass, Set, List, Set, CtBlock)

createEnum

CtEnum<?> createEnum(String qualifiedName)

See Also:

EnumFactory.create(String)

createEnum

CtEnum<?> createEnum(CtPackage owner,
                     String simpleName)

See Also:

EnumFactory.create(CtPackage, String)

createField

CtField createField(CtType<?> target,
                    Set<ModifierKind> modifiers,
                    CtTypeReference type,
                    String name)

See Also:

FieldFactory.create(CtType, Set, CtTypeReference, String)

createField

CtField createField(CtType<?> target,
                    Set<ModifierKind> modifiers,
                    CtTypeReference type,
                    String name,
                    CtExpression defaultExpression)

See Also:

FieldFactory.create(CtType, Set, CtTypeReference, String, CtExpression)

createField

CtField createField(CtType<?> target,
                    CtField source)

See Also:

FieldFactory.create(CtType, CtField)

createInterface

CtInterface createInterface(CtPackage owner,
                            String simpleName)

See Also:

InterfaceFactory.create(CtPackage, String)

createInterface

CtInterface createInterface(CtType owner,
                            String simpleName)

See Also:

InterfaceFactory.create(CtType, String)

createInterface

CtInterface createInterface(String qualifiedName)

See Also:

InterfaceFactory.create(String)

createMethod

CtMethod createMethod(CtClass<?> target,
                      Set<ModifierKind> modifiers,
                      CtTypeReference returnType,
                      String name,
                      List<CtParameter<?>> parameters,
                      Set<CtTypeReference<? extends Throwable>> thrownTypes,
                      CtBlock body)

See Also:

MethodFactory.create(CtClass, Set, CtTypeReference, String, List, Set, CtBlock)

createMethod

CtMethod createMethod(CtType<?> target,
                      CtMethod source,
                      boolean redirectReferences)

See Also:

MethodFactory.create(CtType, CtMethod, boolean)

createMethod

CtMethod createMethod(CtType<?> target,
                      Set<ModifierKind> modifiers,
                      CtTypeReference returnType,
                      String name,
                      List<CtParameter<?>> parameters,
                      Set<CtTypeReference<? extends Throwable>> thrownTypes)

See Also:

MethodFactory.create(CtType, Set, CtTypeReference, String, List, Set)

createPackage

CtPackage createPackage(CtPackage parent,
                        String simpleName)

See Also:

PackageFactory.create(CtPackage, String)

createElement

CtElement createElement(Class<? extends CtElement> klass)

See Also:

CoreFactory.create(Class)

createImport

CtImport createImport(CtReference reference)

See Also:

TypeFactory.createImport(CtReference)

createUnresolvedImport

CtImport createUnresolvedImport(String reference,
                                boolean isStatic)

See Also:

TypeFactory.createUnresolvedImport(String,boolean)

createTypeMemberWildcardImportReference

CtTypeMemberWildcardImportReference createTypeMemberWildcardImportReference(CtTypeReference<?> typeReference)

See Also:

TypeFactory.createTypeMemberWildcardImportReference(CtTypeReference)

createPackageExport

CtPackageExport createPackageExport(CtPackageReference ctPackageReference)

See Also:

ModuleFactory.createPackageExport(CtPackageReference)

createProvidedService

CtProvidedService createProvidedService(CtTypeReference ctTypeReference)

See Also:

ModuleFactory.createProvidedService(CtTypeReference)

createModuleRequirement

CtModuleRequirement createModuleRequirement(CtModuleReference ctModuleReference)

See Also:

ModuleFactory.createModuleRequirement(CtModuleReference)

createModule

CtModule createModule(String moduleName)

See Also:

ModuleFactory.getOrCreate(String)

createModuleReference

CtModuleReference createModuleReference(CtModule ctModule)

See Also:

ModuleFactory.createReference(CtModule)

createUsedService

CtUsedService createUsedService(CtTypeReference typeReference)

See Also:

ModuleFactory.createUsedService(CtTypeReference)

createPartialSourcePosition

SourcePosition createPartialSourcePosition(CompilationUnit compilationUnit)

See Also:

CoreFactory.createPartialSourcePosition(CompilationUnit)

createPackageDeclaration

CtPackageDeclaration createPackageDeclaration(CtPackageReference packageRef)

See Also:

PackageFactory.createPackageDeclaration(CtPackageReference)

createReference

<T> CtTypeReference<T> createReference(String qualifiedName)

See Also:

TypeFactory.createReference(String)

createSimplyQualifiedReference

<T> CtTypeReference<T> createSimplyQualifiedReference(String qualifiedName)

See Also:

TypeFactory.createSimplyQualifiedReference(String)

createYieldStatement

CtYieldStatement createYieldStatement(boolean isImplicit)

See Also:

CoreFactory.createYieldStatement()