DefaultCoreFactory (Spoon Core 8.2.0-SNAPSHOT API)

java.lang.Object
- spoon.reflect.factory.SubFactory
- - spoon.support.DefaultCoreFactory

All Implemented Interfaces:

CoreFactory
```
public class DefaultCoreFactory
extends SubFactory
implements CoreFactory
```
This class implements a default core factory for Spoon's meta-model. This implementation is done with regular Java classes (POJOs).

Field Summary
- Fields inherited from class spoon.reflect.factory.SubFactory
  factory

Constructor Summary

Constructors
Constructor and Description

DefaultCoreFactory()
Default constructor.

Constructors
Constructor and Description
`DefaultCoreFactory()` Default constructor.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<T extends CtElement> T`	`clone(T object)` Recursively clones a given element of the metamodel and all its child elements.
`CtElement`	`create(Class<? extends CtElement> klass)` Creates an instance of the concrete metamodel class given as parameter.
`<A extends Annotation> CtAnnotation<A>`	`createAnnotation()` Creates an annotation.
`<T> CtAnnotationFieldAccess<T>`	`createAnnotationFieldAccess()` Create an access to annotation value
`<T> CtAnnotationMethod<T>`	`createAnnotationMethod()` Creates an annotation method.
`<T extends Annotation> CtAnnotationType<T>`	`createAnnotationType()` Creates an annotation type.
`CtAnonymousExecutable`	`createAnonymousExecutable()` Creates an anonymous executable.
`<T> CtArrayRead<T>`	`createArrayRead()` Creates an array read access expression.
`<T> CtArrayTypeReference<T>`	`createArrayTypeReference()` Creates an array type reference.
`<T> CtArrayWrite<T>`	`createArrayWrite()` Creates an array write access expression.
`<T> CtAssert<T>`	`createAssert()` Creates an `assert` statement.
`<T,A extends T> CtAssignment<T,A>`	`createAssignment()` Creates an assignment expression.
`<T> CtBinaryOperator<T>`	`createBinaryOperator()` Creates a binary operator.
`<R> CtBlock<R>`	`createBlock()` Creates a block.
`BodyHolderSourcePosition`	`createBodyHolderSourcePosition(CompilationUnit compilationUnit, int nameStart, int nameEnd, int modifierStart, int modifierEnd, int declarationStart, int declarationEnd, int bodyStart, int bodyEnd, int[] lineSeparatorPositions)` Creates a body holder source position.
`CtBreak`	`createBreak()` Creates a `break` statement.
`<S> CtCase<S>`	`createCase()` Creates a `case` clause.
`CtCatch`	`createCatch()` Creates a `catch` clause.
`<T> CtCatchVariable<T>`	`createCatchVariable()` Creates a catch variable declaration statement.
`<T> CtCatchVariableReference<T>`	`createCatchVariableReference()` Creates a catch variable reference.
`<T> CtClass<T>`	`createClass()` Creates a class.
`<T> CtCodeSnippetExpression<T>`	`createCodeSnippetExpression()` Creates a code snippet expression.
`CtCodeSnippetStatement`	`createCodeSnippetStatement()` Creates a code snippet statement.
`CtComment`	`createComment()` Creates a comment.
`CompilationUnit`	`createCompilationUnit()` Creates a compilation unit.
`CompoundSourcePosition`	`createCompoundSourcePosition(CompilationUnit compilationUnit, int startSource, int end, int declarationStart, int declarationEnd, int[] lineSeparatorPositions)` Creates a compound source position.
`<T> CtConditional<T>`	`createConditional()` Creates a conditional expression (`boolExpr?ifTrue:ifFalse`).
`<T> CtConstructor<T>`	`createConstructor()` Creates a constructor.
`<T> CtConstructorCall<T>`	`createConstructorCall()` Creates a constructor call expression.
`CtContinue`	`createContinue()` Creates a `continue` statement.
`DeclarationSourcePosition`	`createDeclarationSourcePosition(CompilationUnit compilationUnit, int startSource, int end, int modifierStart, int modifierEnd, int declarationStart, int declarationEnd, int[] lineSeparatorPositions)` Creates a declaration source position.
`CtDo`	`createDo()` Creates a `do` loop.
`<T extends Enum<?>> CtEnum<T>`	`createEnum()` Creates an enum.
`<T> CtEnumValue<T>`	`createEnumValue()` Creates an enum value.
`<T> CtExecutableReference<T>`	`createExecutableReference()` Creates an executable reference.
`<T,E extends CtExpression<?>> CtExecutableReferenceExpression<T,E>`	`createExecutableReferenceExpression()` Creates a new executable reference expression.
`<T> CtField<T>`	`createField()` Creates a field.
`<T> CtFieldRead<T>`	`createFieldRead()` Creates a field read access.
`<T> CtFieldReference<T>`	`createFieldReference()` Creates a field reference.
`<T> CtFieldWrite<T>`	`createFieldWrite()` Creates a field write access.
`CtFor`	`createFor()` Creates a `for` loop.
`CtForEach`	`createForEach()` Creates a `foreach` loop.
`CtIf`	`createIf()` Creates an `if` statement.
`CtImport`	`createImport()` Creates an import.
`<T> CtInterface<T>`	`createInterface()` Creates an interface.
`<T> CtIntersectionTypeReference<T>`	`createIntersectionTypeReference()` Creates an intersection type reference.
`<T> CtConstructor<T>`	`createInvisibleArrayConstructor()` Creates an invisible array constructor.
`<T> CtInvocation<T>`	`createInvocation()` Creates an invocation expression.
`CtJavaDoc`	`createJavaDoc()` Creates a javadoc comment.
`CtJavaDocTag`	`createJavaDocTag()` Creates a javadoc tag.
`<T> CtLambda<T>`	`createLambda()` Creates a new anonymous method expression.
`<T> CtLiteral<T>`	`createLiteral()` Creates a literal expression.
`<T> CtLocalVariable<T>`	`createLocalVariable()` Creates a local variable declaration statement.
`<T> CtLocalVariableReference<T>`	`createLocalVariableReference()` Creates a local variable reference.
`<T> CtMethod<T>`	`createMethod()` Creates a method.
`CtModule`	`createModule()` Creates a Java 9 module
`CtModuleReference`	`createModuleReference()` Creates a reference to a Java 9 module
`CtModuleRequirement`	`createModuleRequirement()` Creates a "requires" directive for a Java 9 module file
`<T> CtNewArray<T>`	`createNewArray()` Creates a new array expression.
`<T> CtNewClass<T>`	`createNewClass()` Creates a new anonymous class expression.
`<T,A extends T> CtOperatorAssignment<T,A>`	`createOperatorAssignment()` Creates a new operator assignment (like +=).
`CtPackage`	`createPackage()` Creates a package.
`CtPackageDeclaration`	`createPackageDeclaration()` Creates a package declaration.
`CtPackageExport`	`createPackageExport()` Creates a "export" directive for a Java 9 module file
`CtPackageReference`	`createPackageReference()` Creates a package reference.
`<T> CtParameter<T>`	`createParameter()` Creates a parameter.
`<T> CtParameterReference<T>`	`createParameterReference()` Creates a parameter reference.
`SourcePosition`	`createPartialSourcePosition(CompilationUnit compilationUnit)` Creates a source position that points to the given compilation unit
`CtProvidedService`	`createProvidedService()` Creates a "provides" directive for a Java 9 module file
`<R> CtReturn<R>`	`createReturn()` Creates a `return` statement.
`SourcePosition`	`createSourcePosition(CompilationUnit compilationUnit, int startSource, int end, int[] lineSeparatorPositions)` Creates a source position.
`<R> CtStatementList`	`createStatementList()` Creates a statement list.
`<T> CtSuperAccess<T>`	`createSuperAccess()` Creates an access expression to super.
`<S> CtSwitch<S>`	`createSwitch()` Creates a `switch` statement.
`<T,S> CtSwitchExpression<T,S>`	`createSwitchExpression()` Creates a `switch` expression.
`CtSynchronized`	`createSynchronized()` Creates a `synchronized` statement.
`<T> CtThisAccess<T>`	`createThisAccess()` Creates an access expression to this.
`CtThrow`	`createThrow()` Creates a `throw` statement.
`CtTry`	`createTry()` Creates a `try` block.
`CtTryWithResource`	`createTryWithResource()` Creates a `try` with resource block.
`<T> CtTypeAccess<T>`	`createTypeAccess()` Creates a type access expression.
`CtTypeMemberWildcardImportReference`	`createTypeMemberWildcardImportReference()` Create a wildcard reference to a type member, used in a static import
`CtTypeParameter`	`createTypeParameter()` Creates a type parameter declaration.
`CtTypeParameterReference`	`createTypeParameterReference()` Creates a type parameter reference.
`<T> CtTypeReference<T>`	`createTypeReference()` Creates a type reference.
`<T> CtUnaryOperator<T>`	`createUnaryOperator()` Creates a unary operator expression.
`<T> CtUnboundVariableReference<T>`	`createUnboundVariableReference()` Creates an unbound variable used in noclasspath.
`CtImport`	`createUnresolvedImport()` Creates an unresolved import.
`CtUsedService`	`createUsedService()` Creates a "uses" directive for a Java 9 module file
`<T> CtVariableRead<T>`	`createVariableRead()` Creates a variable read expression.
`<T> CtVariableWrite<T>`	`createVariableWrite()` Creates a variable write expression.
`CtWhile`	`createWhile()` Creates a `while` loop.
`CtWildcardReference`	`createWildcardReference()` Creates a wildcard reference.
`CtYieldStatement`	`createYieldStatement()` Creates a `yield` statement
`Factory`	`getMainFactory()` Gets the main factory of that core factory (cannot be `null`).
`void`	`setMainFactory(Factory mainFactory)` Sets the main factory of that core factory.

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

- Constructor Detail
  - DefaultCoreFactory
```
public DefaultCoreFactory()
```
    Default constructor.
- Method Detail
  - clone
```
public <T extends CtElement> T clone(T object)
```
    Description copied from interface: CoreFactory
    
    Recursively clones a given element of the metamodel and all its child elements.
    
    Specified by:
    
    clone in interface CoreFactory
    
    Type Parameters:
    
    T - the element's type
    
    Parameters:
    
    object - the element
    
    Returns:
    
    a clone of element
    
    See Also:
    
    CtElement.clone()
  - createAnnotation
```
public <A extends Annotation> CtAnnotation<A> createAnnotation()
```
    Description copied from interface: CoreFactory
    
    Creates an annotation.
    
    Specified by:
    
    createAnnotation in interface CoreFactory
  - createAnnotationType
```
public <T extends Annotation> CtAnnotationType<T> createAnnotationType()
```
    Description copied from interface: CoreFactory
    
    Creates an annotation type.
    
    Specified by:
    
    createAnnotationType in interface CoreFactory
  - createAnonymousExecutable
```
public CtAnonymousExecutable createAnonymousExecutable()
```
    Description copied from interface: CoreFactory
    
    Creates an anonymous executable.
    
    Specified by:
    
    createAnonymousExecutable in interface CoreFactory
  - createArrayRead
```
public <T> CtArrayRead<T> createArrayRead()
```
    Description copied from interface: CoreFactory
    
    Creates an array read access expression.
    
    Specified by:
    
    createArrayRead in interface CoreFactory
  - createArrayWrite
```
public <T> CtArrayWrite<T> createArrayWrite()
```
    Description copied from interface: CoreFactory
    
    Creates an array write access expression.
    
    Specified by:
    
    createArrayWrite in interface CoreFactory
  - createArrayTypeReference
```
public <T> CtArrayTypeReference<T> createArrayTypeReference()
```
    Description copied from interface: CoreFactory
    
    Creates an array type reference.
    
    Specified by:
    
    createArrayTypeReference in interface CoreFactory
  - createAssert
```
public <T> CtAssert<T> createAssert()
```
    Description copied from interface: CoreFactory
    
    Creates an assert statement.
    
    Specified by:
    
    createAssert in interface CoreFactory
  - createAssignment
```
public <T,A extends T> CtAssignment<T,A> createAssignment()
```
    Description copied from interface: CoreFactory
    
    Creates an assignment expression.
    
    Specified by:
    
    createAssignment in interface CoreFactory
  - createBinaryOperator
```
public <T> CtBinaryOperator<T> createBinaryOperator()
```
    Description copied from interface: CoreFactory
    
    Creates a binary operator.
    
    Specified by:
    
    createBinaryOperator in interface CoreFactory
  - createBlock
```
public <R> CtBlock<R> createBlock()
```
    Description copied from interface: CoreFactory
    
    Creates a block.
    
    Specified by:
    
    createBlock in interface CoreFactory
  - createBreak
```
public CtBreak createBreak()
```
    Description copied from interface: CoreFactory
    
    Creates a break statement.
    
    Specified by:
    
    createBreak in interface CoreFactory
  - createCase
```
public <S> CtCase<S> createCase()
```
    Description copied from interface: CoreFactory
    
    Creates a case clause.
    
    Specified by:
    
    createCase in interface CoreFactory
  - createCatch
```
public CtCatch createCatch()
```
    Description copied from interface: CoreFactory
    
    Creates a catch clause.
    
    Specified by:
    
    createCatch in interface CoreFactory
  - createClass
```
public <T> CtClass<T> createClass()
```
    Description copied from interface: CoreFactory
    
    Creates a class.
    
    Specified by:
    
    createClass in interface CoreFactory
  - createTypeParameter
```
public CtTypeParameter createTypeParameter()
```
    Description copied from interface: CoreFactory
    
    Creates a type parameter declaration.
    
    Specified by:
    
    createTypeParameter in interface CoreFactory
  - createConditional
```
public <T> CtConditional<T> createConditional()
```
    Description copied from interface: CoreFactory
    
    Creates a conditional expression (boolExpr?ifTrue:ifFalse).
    
    Specified by:
    
    createConditional in interface CoreFactory
  - createConstructor
```
public <T> CtConstructor<T> createConstructor()
```
    Description copied from interface: CoreFactory
    
    Creates a constructor.
    
    Specified by:
    
    createConstructor in interface CoreFactory
  - createInvisibleArrayConstructor
```
public <T> CtConstructor<T> createInvisibleArrayConstructor()
```
    Description copied from interface: CoreFactory
    
    Creates an invisible array constructor.
    
    Specified by:
    
    createInvisibleArrayConstructor in interface CoreFactory
  - createContinue
```
public CtContinue createContinue()
```
    Description copied from interface: CoreFactory
    
    Creates a continue statement.
    
    Specified by:
    
    createContinue in interface CoreFactory
  - createDo
```
public CtDo createDo()
```
    Description copied from interface: CoreFactory
    
    Creates a do loop.
    
    Specified by:
    
    createDo in interface CoreFactory
  - createEnum
```
public <T extends Enum<?>> CtEnum<T> createEnum()
```
    Description copied from interface: CoreFactory
    
    Creates an enum.
    
    Specified by:
    
    createEnum in interface CoreFactory
  - createExecutableReference
```
public <T> CtExecutableReference<T> createExecutableReference()
```
    Description copied from interface: CoreFactory
    
    Creates an executable reference.
    
    Specified by:
    
    createExecutableReference in interface CoreFactory
  - createField
```
public <T> CtField<T> createField()
```
    Description copied from interface: CoreFactory
    
    Creates a field.
    
    Specified by:
    
    createField in interface CoreFactory
  - createEnumValue
```
public <T> CtEnumValue<T> createEnumValue()
```
    Description copied from interface: CoreFactory
    
    Creates an enum value.
    
    Specified by:
    
    createEnumValue in interface CoreFactory
  - createFieldRead
```
public <T> CtFieldRead<T> createFieldRead()
```
    Description copied from interface: CoreFactory
    
    Creates a field read access.
    
    Specified by:
    
    createFieldRead in interface CoreFactory
  - createFieldWrite
```
public <T> CtFieldWrite<T> createFieldWrite()
```
    Description copied from interface: CoreFactory
    
    Creates a field write access.
    
    Specified by:
    
    createFieldWrite in interface CoreFactory
  - createAnnotationFieldAccess
```
public <T> CtAnnotationFieldAccess<T> createAnnotationFieldAccess()
```
    Description copied from interface: CoreFactory
    
    Create an access to annotation value
    
    Specified by:
    
    createAnnotationFieldAccess in interface CoreFactory
    
    Returns:
  - createUnboundVariableReference
```
public <T> CtUnboundVariableReference<T> createUnboundVariableReference()
```
    Description copied from interface: CoreFactory
    
    Creates an unbound variable used in noclasspath.
    
    Specified by:
    
    createUnboundVariableReference in interface CoreFactory
  - createFieldReference
```
public <T> CtFieldReference<T> createFieldReference()
```
    Description copied from interface: CoreFactory
    
    Creates a field reference.
    
    Specified by:
    
    createFieldReference in interface CoreFactory
  - createFor
```
public CtFor createFor()
```
    Description copied from interface: CoreFactory
    
    Creates a for loop.
    
    Specified by:
    
    createFor in interface CoreFactory
  - createForEach
```
public CtForEach createForEach()
```
    Description copied from interface: CoreFactory
    
    Creates a foreach loop.
    
    Specified by:
    
    createForEach in interface CoreFactory
  - createIf
```
public CtIf createIf()
```
    Description copied from interface: CoreFactory
    
    Creates an if statement.
    
    Specified by:
    
    createIf in interface CoreFactory
  - createInterface
```
public <T> CtInterface<T> createInterface()
```
    Description copied from interface: CoreFactory
    
    Creates an interface.
    
    Specified by:
    
    createInterface in interface CoreFactory
  - createInvocation
```
public <T> CtInvocation<T> createInvocation()
```
    Description copied from interface: CoreFactory
    
    Creates an invocation expression.
    
    Specified by:
    
    createInvocation in interface CoreFactory
  - createLiteral
```
public <T> CtLiteral<T> createLiteral()
```
    Description copied from interface: CoreFactory
    
    Creates a literal expression.
    
    Specified by:
    
    createLiteral in interface CoreFactory
  - createLocalVariable
```
public <T> CtLocalVariable<T> createLocalVariable()
```
    Description copied from interface: CoreFactory
    
    Creates a local variable declaration statement.
    
    Specified by:
    
    createLocalVariable in interface CoreFactory
  - createLocalVariableReference
```
public <T> CtLocalVariableReference<T> createLocalVariableReference()
```
    Description copied from interface: CoreFactory
    
    Creates a local variable reference.
    
    Specified by:
    
    createLocalVariableReference in interface CoreFactory
  - createCatchVariable
```
public <T> CtCatchVariable<T> createCatchVariable()
```
    Description copied from interface: CoreFactory
    
    Creates a catch variable declaration statement.
    
    Specified by:
    
    createCatchVariable in interface CoreFactory
  - createCatchVariableReference
```
public <T> CtCatchVariableReference<T> createCatchVariableReference()
```
    Description copied from interface: CoreFactory
    
    Creates a catch variable reference.
    
    Specified by:
    
    createCatchVariableReference in interface CoreFactory
  - createMethod
```
public <T> CtMethod<T> createMethod()
```
    Description copied from interface: CoreFactory
    
    Creates a method.
    
    Specified by:
    
    createMethod in interface CoreFactory
  - createAnnotationMethod
```
public <T> CtAnnotationMethod<T> createAnnotationMethod()
```
    Description copied from interface: CoreFactory
    
    Creates an annotation method.
    
    Specified by:
    
    createAnnotationMethod in interface CoreFactory
  - createNewArray
```
public <T> CtNewArray<T> createNewArray()
```
    Description copied from interface: CoreFactory
    
    Creates a new array expression.
    
    Specified by:
    
    createNewArray in interface CoreFactory
  - createConstructorCall
```
public <T> CtConstructorCall<T> createConstructorCall()
```
    Description copied from interface: CoreFactory
    Creates a constructor call expression. Example to build "new Foo()":
```
     CtConstructorCall call = spoon.getFactory().Core().createConstructorCall();
     call.setType(spoon.getFactory().Core().createTypeReference().setSimpleName("Foo"));
 
```
    Specified by:
    
    createConstructorCall in interface CoreFactory
  - createNewClass
```
public <T> CtNewClass<T> createNewClass()
```
    Description copied from interface: CoreFactory
    
    Creates a new anonymous class expression.
    
    Specified by:
    
    createNewClass in interface CoreFactory
  - createLambda
```
public <T> CtLambda<T> createLambda()
```
    Description copied from interface: CoreFactory
    
    Creates a new anonymous method expression.
    
    Specified by:
    
    createLambda in interface CoreFactory
  - createExecutableReferenceExpression
```
public <T,E extends CtExpression<?>> CtExecutableReferenceExpression<T,E> createExecutableReferenceExpression()
```
    Description copied from interface: CoreFactory
    
    Creates a new executable reference expression.
    
    Specified by:
    
    createExecutableReferenceExpression in interface CoreFactory
  - createOperatorAssignment
```
public <T,A extends T> CtOperatorAssignment<T,A> createOperatorAssignment()
```
    Description copied from interface: CoreFactory
    
    Creates a new operator assignment (like +=).
    
    Specified by:
    
    createOperatorAssignment in interface CoreFactory
  - createPackage
```
public CtPackage createPackage()
```
    Description copied from interface: CoreFactory
    
    Creates a package.
    
    Specified by:
    
    createPackage in interface CoreFactory
  - createPackageReference
```
public CtPackageReference createPackageReference()
```
    Description copied from interface: CoreFactory
    
    Creates a package reference.
    
    Specified by:
    
    createPackageReference in interface CoreFactory
  - createParameter
```
public <T> CtParameter<T> createParameter()
```
    Description copied from interface: CoreFactory
    
    Creates a parameter.
    
    Specified by:
    
    createParameter in interface CoreFactory
  - createParameterReference
```
public <T> CtParameterReference<T> createParameterReference()
```
    Description copied from interface: CoreFactory
    
    Creates a parameter reference.
    
    Specified by:
    
    createParameterReference in interface CoreFactory
  - createReturn
```
public <R> CtReturn<R> createReturn()
```
    Description copied from interface: CoreFactory
    
    Creates a return statement.
    
    Specified by:
    
    createReturn in interface CoreFactory
  - createStatementList
```
public <R> CtStatementList createStatementList()
```
    Description copied from interface: CoreFactory
    
    Creates a statement list.
    
    Specified by:
    
    createStatementList in interface CoreFactory
  - createSwitch
```
public <S> CtSwitch<S> createSwitch()
```
    Description copied from interface: CoreFactory
    
    Creates a switch statement.
    
    Specified by:
    
    createSwitch in interface CoreFactory
  - createSwitchExpression
```
public <T,S> CtSwitchExpression<T,S> createSwitchExpression()
```
    Description copied from interface: CoreFactory
    
    Creates a switch expression.
    
    Specified by:
    
    createSwitchExpression in interface CoreFactory
  - createSynchronized
```
public CtSynchronized createSynchronized()
```
    Description copied from interface: CoreFactory
    
    Creates a synchronized statement.
    
    Specified by:
    
    createSynchronized in interface CoreFactory
  - createThrow
```
public CtThrow createThrow()
```
    Description copied from interface: CoreFactory
    
    Creates a throw statement.
    
    Specified by:
    
    createThrow in interface CoreFactory
  - createTry
```
public CtTry createTry()
```
    Description copied from interface: CoreFactory
    
    Creates a try block.
    
    Specified by:
    
    createTry in interface CoreFactory
  - createTryWithResource
```
public CtTryWithResource createTryWithResource()
```
    Description copied from interface: CoreFactory
    
    Creates a try with resource block.
    
    Specified by:
    
    createTryWithResource in interface CoreFactory
  - createTypeParameterReference
```
public CtTypeParameterReference createTypeParameterReference()
```
    Description copied from interface: CoreFactory
    
    Creates a type parameter reference.
    
    Specified by:
    
    createTypeParameterReference in interface CoreFactory
  - createWildcardReference
```
public CtWildcardReference createWildcardReference()
```
    Description copied from interface: CoreFactory
    
    Creates a wildcard reference.
    
    Specified by:
    
    createWildcardReference in interface CoreFactory
  - createIntersectionTypeReference
```
public <T> CtIntersectionTypeReference<T> createIntersectionTypeReference()
```
    Description copied from interface: CoreFactory
    
    Creates an intersection type reference.
    
    Specified by:
    
    createIntersectionTypeReference in interface CoreFactory
  - createTypeReference
```
public <T> CtTypeReference<T> createTypeReference()
```
    Description copied from interface: CoreFactory
    
    Creates a type reference.
    
    Specified by:
    
    createTypeReference in interface CoreFactory
  - createTypeAccess
```
public <T> CtTypeAccess<T> createTypeAccess()
```
    Description copied from interface: CoreFactory
    
    Creates a type access expression.
    
    Specified by:
    
    createTypeAccess in interface CoreFactory
  - createUnaryOperator
```
public <T> CtUnaryOperator<T> createUnaryOperator()
```
    Description copied from interface: CoreFactory
    
    Creates a unary operator expression.
    
    Specified by:
    
    createUnaryOperator in interface CoreFactory
  - createVariableRead
```
public <T> CtVariableRead<T> createVariableRead()
```
    Description copied from interface: CoreFactory
    
    Creates a variable read expression.
    
    Specified by:
    
    createVariableRead in interface CoreFactory
  - createVariableWrite
```
public <T> CtVariableWrite<T> createVariableWrite()
```
    Description copied from interface: CoreFactory
    
    Creates a variable write expression.
    
    Specified by:
    
    createVariableWrite in interface CoreFactory
  - createCodeSnippetExpression
```
public <T> CtCodeSnippetExpression<T> createCodeSnippetExpression()
```
    Description copied from interface: CoreFactory
    
    Creates a code snippet expression.
    
    Specified by:
    
    createCodeSnippetExpression in interface CoreFactory
  - createCodeSnippetStatement
```
public CtCodeSnippetStatement createCodeSnippetStatement()
```
    Description copied from interface: CoreFactory
    
    Creates a code snippet statement.
    
    Specified by:
    
    createCodeSnippetStatement in interface CoreFactory
  - createComment
```
public CtComment createComment()
```
    Description copied from interface: CoreFactory
    
    Creates a comment.
    
    Specified by:
    
    createComment in interface CoreFactory
  - createJavaDoc
```
public CtJavaDoc createJavaDoc()
```
    Description copied from interface: CoreFactory
    
    Creates a javadoc comment.
    
    Specified by:
    
    createJavaDoc in interface CoreFactory
  - createJavaDocTag
```
public CtJavaDocTag createJavaDocTag()
```
    Description copied from interface: CoreFactory
    
    Creates a javadoc tag.
    
    Specified by:
    
    createJavaDocTag in interface CoreFactory
  - createWhile
```
public CtWhile createWhile()
```
    Description copied from interface: CoreFactory
    
    Creates a while loop.
    
    Specified by:
    
    createWhile in interface CoreFactory
  - createImport
```
public CtImport createImport()
```
    Description copied from interface: CoreFactory
    
    Creates an import.
    
    Specified by:
    
    createImport in interface CoreFactory
  - createUnresolvedImport
```
public CtImport createUnresolvedImport()
```
    Description copied from interface: CoreFactory
    
    Creates an unresolved import. CtUnresolvedImport stores the original content of the imort as a String in order to be able to restituate it when pretty printing.
    
    Specified by:
    
    createUnresolvedImport in interface CoreFactory
  - createPackageDeclaration
```
public CtPackageDeclaration createPackageDeclaration()
```
    Description copied from interface: CoreFactory
    
    Creates a package declaration.
    
    Specified by:
    
    createPackageDeclaration in interface CoreFactory
  - getMainFactory
```
public Factory getMainFactory()
```
    Description copied from interface: CoreFactory
    
    Gets the main factory of that core factory (cannot be null).
    
    Specified by:
    
    getMainFactory in interface CoreFactory
  - setMainFactory
```
public void setMainFactory(Factory mainFactory)
```
    Description copied from interface: CoreFactory
    
    Sets the main factory of that core factory.
    
    Specified by:
    
    setMainFactory in interface CoreFactory
  - createSourcePosition
```
public SourcePosition createSourcePosition(CompilationUnit compilationUnit,
                                           int startSource,
                                           int end,
                                           int[] lineSeparatorPositions)
```
    Description copied from interface: CoreFactory
    
    Creates a source position.
    
    Specified by:
    
    createSourcePosition in interface CoreFactory
  - createPartialSourcePosition
```
public SourcePosition createPartialSourcePosition(CompilationUnit compilationUnit)
```
    Description copied from interface: CoreFactory
    
    Creates a source position that points to the given compilation unit
    
    Specified by:
    
    createPartialSourcePosition in interface CoreFactory
  - createCompoundSourcePosition
```
public CompoundSourcePosition createCompoundSourcePosition(CompilationUnit compilationUnit,
                                                           int startSource,
                                                           int end,
                                                           int declarationStart,
                                                           int declarationEnd,
                                                           int[] lineSeparatorPositions)
```
    Description copied from interface: CoreFactory
    
    Creates a compound source position.
    
    Specified by:
    
    createCompoundSourcePosition in interface CoreFactory
  - createDeclarationSourcePosition
```
public DeclarationSourcePosition createDeclarationSourcePosition(CompilationUnit compilationUnit,
                                                                 int startSource,
                                                                 int end,
                                                                 int modifierStart,
                                                                 int modifierEnd,
                                                                 int declarationStart,
                                                                 int declarationEnd,
                                                                 int[] lineSeparatorPositions)
```
    Description copied from interface: CoreFactory
    
    Creates a declaration source position.
    
    Specified by:
    
    createDeclarationSourcePosition in interface CoreFactory
  - createBodyHolderSourcePosition
```
public BodyHolderSourcePosition createBodyHolderSourcePosition(CompilationUnit compilationUnit,
                                                               int nameStart,
                                                               int nameEnd,
                                                               int modifierStart,
                                                               int modifierEnd,
                                                               int declarationStart,
                                                               int declarationEnd,
                                                               int bodyStart,
                                                               int bodyEnd,
                                                               int[] lineSeparatorPositions)
```
    Description copied from interface: CoreFactory
    
    Creates a body holder source position.
    
    Specified by:
    
    createBodyHolderSourcePosition in interface CoreFactory
  - createCompilationUnit
```
public CompilationUnit createCompilationUnit()
```
    Description copied from interface: CoreFactory
    
    Creates a compilation unit.
    
    Specified by:
    
    createCompilationUnit in interface CoreFactory
  - createThisAccess
```
public <T> CtThisAccess<T> createThisAccess()
```
    Description copied from interface: CoreFactory
    
    Creates an access expression to this.
    
    Specified by:
    
    createThisAccess in interface CoreFactory
  - createSuperAccess
```
public <T> CtSuperAccess<T> createSuperAccess()
```
    Description copied from interface: CoreFactory
    
    Creates an access expression to super.
    
    Specified by:
    
    createSuperAccess in interface CoreFactory
  - create
```
public CtElement create(Class<? extends CtElement> klass)
```
    Description copied from interface: CoreFactory
    
    Creates an instance of the concrete metamodel class given as parameter. This is in particular useful when one uses reflection.
    
    Specified by:
    
    create in interface CoreFactory
  - createTypeMemberWildcardImportReference
```
public CtTypeMemberWildcardImportReference createTypeMemberWildcardImportReference()
```
    Description copied from interface: CoreFactory
    
    Create a wildcard reference to a type member, used in a static import
    
    Specified by:
    
    createTypeMemberWildcardImportReference in interface CoreFactory
  - createModule
```
public CtModule createModule()
```
    Description copied from interface: CoreFactory
    
    Creates a Java 9 module
    
    Specified by:
    
    createModule in interface CoreFactory
  - createModuleReference
```
public CtModuleReference createModuleReference()
```
    Description copied from interface: CoreFactory
    
    Creates a reference to a Java 9 module
    
    Specified by:
    
    createModuleReference in interface CoreFactory
  - createModuleRequirement
```
public CtModuleRequirement createModuleRequirement()
```
    Description copied from interface: CoreFactory
    
    Creates a "requires" directive for a Java 9 module file
    
    Specified by:
    
    createModuleRequirement in interface CoreFactory
  - createPackageExport
```
public CtPackageExport createPackageExport()
```
    Description copied from interface: CoreFactory
    
    Creates a "export" directive for a Java 9 module file
    
    Specified by:
    
    createPackageExport in interface CoreFactory
  - createProvidedService
```
public CtProvidedService createProvidedService()
```
    Description copied from interface: CoreFactory
    
    Creates a "provides" directive for a Java 9 module file
    
    Specified by:
    
    createProvidedService in interface CoreFactory
  - createUsedService
```
public CtUsedService createUsedService()
```
    Description copied from interface: CoreFactory
    
    Creates a "uses" directive for a Java 9 module file
    
    Specified by:
    
    createUsedService in interface CoreFactory
  - createYieldStatement
```
public CtYieldStatement createYieldStatement()
```
    Description copied from interface: CoreFactory
    
    Creates a yield statement
    
    Specified by:
    
    createYieldStatement in interface CoreFactory
    
    Returns:
    
    yieldStatement

Class DefaultCoreFactory

Field Summary

Fields inherited from class spoon.reflect.factory.SubFactory

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DefaultCoreFactory

Method Detail

clone

createAnnotation

createAnnotationType

createAnonymousExecutable

createArrayRead

createArrayWrite

createArrayTypeReference

createAssert

createAssignment

createBinaryOperator

createBlock

createBreak

createCase

createCatch

createClass

createTypeParameter

createConditional

createConstructor

createInvisibleArrayConstructor

createContinue

createDo

createEnum

createExecutableReference

createField

createEnumValue

createFieldRead

createFieldWrite

createAnnotationFieldAccess

createUnboundVariableReference

createFieldReference

createFor

createForEach

createIf

createInterface

createInvocation

createLiteral

createLocalVariable

createLocalVariableReference

createCatchVariable

createCatchVariableReference

createMethod

createAnnotationMethod

createNewArray

createConstructorCall

createNewClass

createLambda

createExecutableReferenceExpression

createOperatorAssignment

createPackage

createPackageReference

createParameter

createParameterReference

createReturn

createStatementList

createSwitch

createSwitchExpression

createSynchronized

createThrow

createTry

createTryWithResource

createTypeParameterReference

createWildcardReference

createIntersectionTypeReference

createTypeReference

createTypeAccess

createUnaryOperator

createVariableRead

createVariableWrite

createCodeSnippetExpression

createCodeSnippetStatement

createComment