FactoryImpl (Spoon Core 7.5.0-beta-1 API)

java.lang.Object
- spoon.reflect.factory.FactoryImpl

All Implemented Interfaces:

Serializable, Factory
```
public class FactoryImpl
extends Object
implements Factory, Serializable
```
Implements Factory

See Also:

Serialized Form

Constructor Summary

Constructors
Constructor and Description
`FactoryImpl(CoreFactory coreFactory, Environment environment)` Should not be called directly.
`FactoryImpl(CoreFactory coreFactory, Environment environment, Factory parentFactory)` A constructor that takes the parent factory

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`AnnotationFactory`	`Annotation()` The `CtAnnotationType` sub-factory.
`ClassFactory`	`Class()` The `CtClass` sub-factory.
`CodeFactory`	`Code()` The `CtCodeElement` sub-factory.
`CompilationUnitFactory`	`CompilationUnit()` The `CompilationUnit` sub-factory.
`ConstructorFactory`	`Constructor()` The `CtConstructor` sub-factory.
`CoreFactory`	`Core()` The core factory.
`<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(CtPackage owner, String simpleName)`
`CtAnnotationType`	`createAnnotationType(String qualifiedName)`
`CtAnonymousExecutable`	`createAnonymous(CtClass<?> target, CtBlock<Void> body)`
`CtAnonymousExecutable`	`createAnonymousExecutable()`
`<T> CtArrayRead<T>`	`createArrayRead()`
`<T> CtArrayTypeReference<T[]>`	`createArrayReference(CtType<T> type)`
`CtArrayTypeReference<?>`	`createArrayReference(CtTypeReference<?> reference, int n)`
`<T> CtArrayTypeReference<T[]>`	`createArrayReference(CtTypeReference<T> reference)`
`<T> CtArrayTypeReference<T>`	`createArrayReference(String qualifiedName)`
`<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(CtClass<?> declaringClass, String simpleName)`
`CtClass`	`createClass(CtPackage owner, String simpleName)`
`CtClass`	`createClass(String qualifiedName)`
`<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, CtConstructor<?> source)`
`CtConstructor`	`createConstructor(CtClass target, CtMethod<?> source)`
`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)`
`<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(CtPackage owner, String simpleName)`
`CtEnum<?>`	`createEnum(String qualifiedName)`
`<T> CtEnumValue<T>`	`createEnumValue()`
`<T> CtExecutableReference<T>`	`createExecutableReference()`
`<T,E extends CtExpression<?>> CtExecutableReferenceExpression<T,E>`	`createExecutableReferenceExpression()`
`<T> CtField<T>`	`createField()`
`CtField`	`createField(CtType<?> target, CtField source)`
`CtField`	`createField(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference type, String name)`
`CtField`	`createField(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference type, String name, CtExpression defaultExpression)`
`<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(CtPackage owner, String simpleName)`
`CtInterface`	`createInterface(CtType owner, String simpleName)`
`CtInterface`	`createInterface(String qualifiedName)`
`<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, CtExpression<?>... arguments)`
`<T> CtInvocation<T>`	`createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, List<CtExpression<?>> arguments)`
`CtJavaDocTag`	`createJavaDocTag(String content, CtJavaDocTag.TagType type)`
`<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, CtMethod source, boolean redirectReferences)`
`CtMethod`	`createMethod(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference returnType, String name, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes)`
`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()`
`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()`
`CtSynchronized`	`createSynchronized()`
`<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()`
`CtWhile`	`createWhile()`
`CtWildcardReference`	`createWildcardReference()`
`String`	`dedup(String symbol)` Returns a String equal to the given symbol.
`EnumFactory`	`Enum()` The `CtEnum` sub-factory.
`EvalFactory`	`Eval()` The evaluators sub-factory.
`ExecutableFactory`	`Executable()` The `CtExecutable` sub-factory.
`FieldFactory`	`Field()` The `CtField` sub-factory.
`Environment`	`getEnvironment()` Gets the Spoon environment that encloses this factory.
`CtModel`	`getModel()` returns the Spoon model that has been built with this factory or one of its subfactories
`Factory`	`getParentFactory()` Returns the parent of this factory.
`InterfaceFactory`	`Interface()` The `CtInterface` sub-factory.
`MethodFactory`	`Method()` The `CtMethod` sub-factory.
`ModuleFactory`	`Module()` The module sub-factory
`PackageFactory`	`Package()` The `CtPackage` sub-factory.
`QueryFactory`	`Query()` The query sub-factory.
`TypeFactory`	`Type()` The `CtType` sub-factory.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

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

Class FactoryImpl

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

FactoryImpl

FactoryImpl

Method Detail

getParentFactory

Annotation

Class

Code

Constructor

Core

Enum

getEnvironment

Executable

Eval

Field

Interface

Method

Package

CompilationUnit

Type

Query

Module

dedup

getModel

createAnnotation

createVariableAssignment

createStatementList

createCtBlock

createBinaryOperator

createCatchVariable

createCodeSnippetExpression

createConstructorCall

createClassAccess

createInvocation

createInvocation

createLiteral

createLocalVariable

createLiteralArray

createNewClass

createVariableAssignments

createThisAccess

createThisAccess

createTypeAccess

createTypeAccess

createTypeAccessWithoutCloningReference

createVariableRead

createCtField

createCatchVariableReference

createLocalVariableReference

createLocalVariableReference

createCtTypeReference

createVariableReads

createCtCatch

createCodeSnippetStatement

createComment

createInlineComment

createJavaDocTag

createCtThrow

createCtPackageReference

createDefault

createAnnotation

createBlock

createReturn

createStatementList

createCase

createSwitch

createEnum

createAnnotationType

createAssignment

createOperatorAssignment

createExecutableReferenceExpression

createAnnotationFieldAccess

createArrayRead

createArrayWrite

createAssert

createBinaryOperator