Uses of Interface
spoon.processing.FactoryAccessor

Packages that use FactoryAccessor

Package	Description
spoon.experimental	this is unstable code, subject to potential complete redesign, not only in snapshots but also in releases.
spoon.processing	This package contains the core API for code processing.
spoon.reflect	This package defines the Spoon's compile-time meta-model of Java programs.
spoon.reflect.code	This package contains the meta-model part that models the executable code (methods and constructors' bodies, field initializers).
spoon.reflect.cu	This package defines compilation units that hold the source code and some classes around them (in most cases, these features should be ignored by the programmers).
spoon.reflect.cu.position
spoon.reflect.declaration	This package contains the meta-model part that models the declarations (program's structures such as classes, fields, etc).
spoon.reflect.factory	This package defines all the sub-factories for the Spoon meta-model.
spoon.reflect.reference	This package defines the references to program elements for the meta-model.
spoon.reflect.visitor	This package defines visitor, scanner, and scanner-based query API for Java programs reified in the meta-model.
spoon.support	This package contains some default implementations for commonly used processing tasks.
spoon.support.reflect.code
spoon.support.reflect.cu
spoon.support.reflect.declaration
spoon.support.reflect.reference

Uses of FactoryAccessor in spoon.experimental

Classes in spoon.experimental that implement FactoryAccessor

Modifier and Type	Class and Description
class	CtUnresolvedImport

Uses of FactoryAccessor in spoon.processing

Subinterfaces of FactoryAccessor in spoon.processing

Modifier and Type	Interface and Description
interface	AnnotationProcessor<A extends java.lang.annotation.Annotation,E extends CtElement> This interface defines an annotation processor.
interface	FileGenerator<T extends CtElement> This interface should be implemented by processing tasks that generate new files as processing results.
interface	ProcessingManager The processing manager defines the API to process a program model of a given Factory with a set of processors.
interface	Processor<E extends CtElement> This interface defines a generic code processor.

Classes in spoon.processing that implement FactoryAccessor

Modifier and Type	Class and Description
class	AbstractAnnotationProcessor<A extends java.lang.annotation.Annotation,E extends CtElement> This class defines an abstract annotation processor to be subclassed by the user for defining new annotation processors including Java 8 annotations.
class	AbstractManualProcessor This class defines an abstract processor to be subclassed by the user for defining new manual processors.
class	AbstractParallelProcessor<E extends CtElement> AbstractParallelProcessor allows using multiple threads for concurrent processing with AbstractProcessor.
class	AbstractProcessor<E extends CtElement> This class defines an abstract processor to be subclassed by the user for defining new processors.
class	SpoonTagger Creates an empty class spoon.Spoon

Uses of FactoryAccessor in spoon.reflect

Classes in spoon.reflect that implement FactoryAccessor

Modifier and Type	Class and Description
static class	CtModelImpl.CtRootPackage

Uses of FactoryAccessor in spoon.reflect.code

Subinterfaces of FactoryAccessor in spoon.reflect.code

Modifier and Type	Interface and Description
interface	CtAbstractInvocation<T> This code element defines an abstract invocation on a CtExecutable.
interface	CtAbstractSwitch<S> This code element defines an abstract switch (either switch statement or switch expression).
interface	CtAnnotationFieldAccess<T> This code element defines an access to a annotation parameter variable.
interface	CtArrayAccess<T,E extends CtExpression<?>> This code element defines a one-dimensional array access.
interface	CtArrayRead<T> This code element defines a read access to an array.
interface	CtArrayWrite<T> This code element defines a write access to an array.
interface	CtAssert<T> This code element defines an assert clause.
interface	CtAssignment<T,A extends T> This code element defines an assignment.
interface	CtBinaryOperator<T> This interface defines a binary operator.
interface	CtBlock<R> This code element represents a block of code, that is to say a list of statements enclosed in curly brackets.
interface	CtBodyHolder This abstract code element defines an element, which contains a body
interface	CtBreak This code element defines a break statement.
interface	CtCase<S> This code element defines a case within a switch-case.
interface	CtCatch This code element defines a catch of a try.
interface	CtCatchVariable<T> This code element defines an exception variable in a catch.
interface	CtCFlowBreak This abstract code element represents all the statements that break the control flow of the program.
interface	CtCodeElement This interface is the root interface of the code elements.
interface	CtCodeSnippetExpression<T> This element is a code snippet that must represent an expression and can thus be inserted in the program's model as is.
interface	CtCodeSnippetStatement This element is a code snippet that must represent a statement and can thus be inserted in the program's model as is.
interface	CtComment This code element defines a comment Example: int x = 0; // a comment
interface	CtConditional<T> This code element defines conditional expressions using the ? (ternary expressions).
interface	CtConstructorCall<T> This code element represents a constructor call.
interface	CtContinue This code element defines the continue statement.
interface	CtDo This code element defines a do loop.
interface	CtExecutableReferenceExpression<T,E extends CtExpression<?>> This abstract code element defines an expression which represents an executable reference.
interface	CtExpression<T> This abstract code element defines a typed expression.
interface	CtFieldAccess<T> This code element defines an access to a field variable (read and write)
interface	CtFieldRead<T> This code element defines a read access to a field.
interface	CtFieldWrite<T> This code element defines a write access to a field.
interface	CtFor This code element defines a for loop.
interface	CtForEach This code element defines a foreach statement.
interface	CtIf This code element represents an if statement.
interface	CtInvocation<T> This code element defines a concrete invocation.
interface	CtJavaDoc This code element defines a javadoc comment Example:
interface	CtJavaDocTag This code element defines a javadoc tag Example:
interface	CtLabelledFlowBreak This abstract code element represents all the statements that break the control flow of the program and which can support a label.
interface	CtLambda<T> This code element represents the creation of a lambda.
interface	CtLiteral<T> This code element defines a literal value (an int, a string, etc).
interface	CtLocalVariable<T> This code element defines a local variable definition (within an executable body).
interface	CtLoop This abstract code element defines a loop.
interface	CtNewArray<T> This code element defines the inline creation of a new array.
interface	CtNewClass<T> This code element represents the creation of a anonymous class.
interface	CtOperatorAssignment<T,A extends T> This code element defines an self-operated assignment such as += or *=.
interface	CtReturn<R> This code element represents a return statement.
interface	CtStatement This abstract code element represents all the statements, which can be part of a block.
interface	CtStatementList This code element represents a list of statements.
interface	CtSuperAccess<T> This code element defines an access to super.
interface	CtSwitch<S> This code element defines a switch statement.
interface	CtSwitchExpression<T,S> This code element defines a switch expression.
interface	CtSynchronized This code element defines a synchronized statement.
interface	CtTargetedExpression<T,E extends CtExpression<?>> This abstract code element defines an expression which contains a target expression.
interface	CtTextBlock This code element defines a Text Block String Literal.
interface	CtThisAccess<T> This code element defines an access to this.
interface	CtThrow This code element defines a throw statement.
interface	CtTry This code element defines a try statement.
interface	CtTryWithResource This code element defines a try with resource statement.
interface	CtTypeAccess<A> This code element represents a type reference usable as an expression.
interface	CtUnaryOperator<T> This code element represents a unary operator.
interface	CtVariableAccess<T> This code element defines an access to a variable (read and write).
interface	CtVariableRead<T> This code element defines an read access to a variable.
interface	CtVariableWrite<T> This code element defines a write to a variable.
interface	CtWhile This code element defines a while loop.
interface	CtYieldStatement This code element defines a yield statement.

Uses of FactoryAccessor in spoon.reflect.cu

Subinterfaces of FactoryAccessor in spoon.reflect.cu

Modifier and Type	Interface and Description
interface	CompilationUnit Deprecated.

Uses of FactoryAccessor in spoon.reflect.cu.position

Classes in spoon.reflect.cu.position that implement FactoryAccessor

Modifier and Type	Class and Description
static class	NoSourcePosition.NullCompilationUnit

Uses of FactoryAccessor in spoon.reflect.declaration

Subinterfaces of FactoryAccessor in spoon.reflect.declaration

Modifier and Type	Interface and Description
interface	CtAnnotation<A extends java.lang.annotation.Annotation> This element represents an annotation on an element.
interface	CtAnnotationMethod<T> This element defines an annotation method declared in an annotation type.
interface	CtAnnotationType<T extends java.lang.annotation.Annotation> This element defines an annotation type.
interface	CtAnonymousExecutable This element defines an anonymous executable block declaration in a class.
interface	CtClass<T> This element represents a class declaration.
interface	CtCompilationUnit Defines a compilation unit.
interface	CtConstructor<T> This element defines a constructor declaration.
interface	CtElement This interface is the root interface for the metamodel elements (any program element).
interface	CtEnum<T extends java.lang.Enum<?>> This element represents an enumeration declaration.
interface	CtEnumValue<T> Corresponds to one enum value specified in an enumeration.
interface	CtExecutable<R> This element represents an executable element such as a method, a constructor, or an anonymous block.
interface	CtField<T> This element defines a field declaration.
interface	CtFormalTypeDeclarer This abstract element defines a declaration that accepts formal type parameters (aka generics), such as a CtType (class A<E>), CtMethod or CtConstructor.
interface	CtImport This element represents an import declaration.
interface	CtInterface<T> This element defines an interface declaration.
interface	CtMethod<T> This element defines a method declaration.
interface	CtModifiable This interface defines an element that accepts modifiers.
interface	CtModule Represents a Java module as defined in Java 9.
interface	CtModuleDirective Represents a directive of a CtModule The directives of a module declaration specify the module's dependences on other modules CtModuleRequirement, the packages it makes available to other modules CtPackageExport, the services it consumes CtUsedService, and the services it provides CtProvidedService.
interface	CtModuleRequirement Represents a require module in a Java module definition The requires directive specifies the name of a module on which the current module has a dependence.
interface	CtMultiTypedElement Defined an element with several types.
interface	CtNamedElement Declares an element that has a name (a class, a method, a variable, etc).
interface	CtPackage This element defines a package declaration.
interface	CtPackageDeclaration This element represents an package declaration.
interface	CtPackageExport Represents an exported or opened package in a Java module The exports directive specifies the name of a package to be exported by the current module.
interface	CtParameter<T> This element defines an executable parameter declaration.
interface	CtProvidedService Represents a provided service in a CtModule.
interface	CtType<T> This abstract element defines a super-type for classes and interfaces, which can declare methods.
interface	CtTypedElement<T> This abstract element defines a typed element.
interface	CtTypeMember This interface represents a member of a class (field, method, nested class or static/instance initializer).
interface	CtTypeParameter This element defines a declaration of a type parameter (aka generics).
interface	CtUsedService Represents the declaration of a used service in a CtModule The uses directive specifies a service for which the current module may discover providers via java.util.ServiceLoader.
interface	CtVariable<T> This abstract element defines a variable declaration.

Uses of FactoryAccessor in spoon.reflect.factory

Classes in spoon.reflect.factory that implement FactoryAccessor

Modifier and Type	Class and Description
static class	ModuleFactory.CtUnnamedModule

Uses of FactoryAccessor in spoon.reflect.reference

Subinterfaces of FactoryAccessor in spoon.reflect.reference

Modifier and Type	Interface and Description
interface	CtArrayTypeReference<T> This interface defines a reference to an array.
interface	CtCatchVariableReference<T> This interface defines a reference to CtCatchVariable.
interface	CtExecutableReference<T> This interface defines a reference to a CtExecutable.
interface	CtFieldReference<T> This interface defines a reference to a CtField.
interface	CtIntersectionTypeReference<T> This interface defines a reference to an intersection type in generics or in casts.
interface	CtLocalVariableReference<T> This interface defines a reference to CtLocalVariable.
interface	CtModuleReference Represents a reference to a CtModule
interface	CtPackageReference This interface defines a reference to a CtPackage.
interface	CtParameterReference<T> This interface defines a reference to a CtParameter of a method.
interface	CtReference This is the root interface for named program element references.
interface	CtTypeMemberWildcardImportReference This interface defines a import reference to all static type members of a type. Example: somePackage.Type.*;
interface	CtTypeParameterReference This interface defines a reference to a type parameter (aka generics).
interface	CtTypeReference<T> This interface defines a reference to a CtType or sub-type.
interface	CtUnboundVariableReference<T> This interface defines a reference to an unbound CtVariable.
interface	CtVariableReference<T> This interface defines a reference to a CtVariable or sub-type.
interface	CtWildcardReference Represents a wildcard in generic type annotations, i.e.

Uses of FactoryAccessor in spoon.reflect.visitor

Classes in spoon.reflect.visitor that implement FactoryAccessor

Modifier and Type	Class and Description
class	ForceFullyQualifiedProcessor Forces fully qualified identifiers by making many elements explicit (by calling setImplicit(false)).
class	ForceImportProcessor Marks all types references as implicit so all types will get imported.
class	ImportCleaner Updates list of import statements of compilation unit following CtElement.isImplicit().
class	ImportConflictDetector Detects conflicts needed to be required be a fully-qualified name.

Uses of FactoryAccessor in spoon.support

Classes in spoon.support that implement FactoryAccessor

Modifier and Type	Class and Description
class	JavaOutputProcessor A processor that generates compilable Java source files from the meta-model.
class	QueueProcessingManager This processing manager applies the processors one by one from the given root element.
class	RuntimeProcessingManager This processing manager implements a blocking processing policy that consists of applying the processors in a FIFO order until no processors remain to be applied.

Uses of FactoryAccessor in spoon.support.reflect.code

Classes in spoon.support.reflect.code that implement FactoryAccessor

Modifier and Type	Class and Description
class	CtAnnotationFieldAccessImpl<T>
class	CtArrayAccessImpl<T,V extends CtExpression<?>>
class	CtArrayReadImpl<T>
class	CtArrayWriteImpl<T>
class	CtAssertImpl<T>
class	CtAssignmentImpl<T,A extends T>
class	CtBinaryOperatorImpl<T>
class	CtBlockImpl<R>
class	CtBreakImpl
class	CtCaseImpl<E>
class	CtCatchImpl
class	CtCatchVariableImpl<T>
class	CtCodeElementImpl
class	CtCodeSnippetExpressionImpl<T>
class	CtCodeSnippetStatementImpl
class	CtCommentImpl
class	CtConditionalImpl<T>
class	CtConstructorCallImpl<T>
class	CtContinueImpl
class	CtDoImpl
class	CtExecutableReferenceExpressionImpl<T,E extends CtExpression<?>>
class	CtExpressionImpl<T>
class	CtFieldAccessImpl<T>
class	CtFieldReadImpl<T>
class	CtFieldWriteImpl<T>
class	CtForEachImpl
class	CtForImpl
class	CtIfImpl
class	CtInvocationImpl<T>
class	CtJavaDocImpl
class	CtJavaDocTagImpl
class	CtLambdaImpl<T>
class	CtLiteralImpl<T>
class	CtLocalVariableImpl<T>
class	CtLoopImpl
class	CtNewArrayImpl<T>
class	CtNewClassImpl<T>
class	CtOperatorAssignmentImpl<T,A extends T>
class	CtReturnImpl<R>
class	CtStatementImpl
class	CtStatementListImpl<R>
class	CtSuperAccessImpl<T>
class	CtSwitchExpressionImpl<T,S>
class	CtSwitchImpl<S>
class	CtSynchronizedImpl
class	CtTargetedExpressionImpl<E,T extends CtExpression<?>>
class	CtTextBlockImpl
class	CtThisAccessImpl<T>
class	CtThrowImpl
class	CtTryImpl
class	CtTryWithResourceImpl
class	CtTypeAccessImpl<A>
class	CtUnaryOperatorImpl<T>
class	CtVariableAccessImpl<T>
class	CtVariableReadImpl<T>
class	CtVariableWriteImpl<T>
class	CtWhileImpl
class	CtYieldStatementImpl CtYieldStatementImpl

Uses of FactoryAccessor in spoon.support.reflect.cu

Classes in spoon.support.reflect.cu that implement FactoryAccessor

Modifier and Type	Class and Description
class	CompilationUnitImpl Implements a compilation unit.

Uses of FactoryAccessor in spoon.support.reflect.declaration

Classes in spoon.support.reflect.declaration that implement FactoryAccessor

Modifier and Type	Class and Description
class	CtAnnotationImpl<A extends java.lang.annotation.Annotation> The implementation for CtAnnotation.
class	CtAnnotationMethodImpl<T> The implementation for CtAnnotationMethod.
class	CtAnnotationTypeImpl<T extends java.lang.annotation.Annotation> The implementation for CtAnnotationType.
class	CtAnonymousExecutableImpl
class	CtClassImpl<T> The implementation for CtClass.
class	CtCompilationUnitImpl Implements a compilation unit.
class	CtConstructorImpl<T>
class	CtElementImpl Contains the default implementation of most CtElement methods.
class	CtEnumImpl<T extends java.lang.Enum<?>>
class	CtEnumValueImpl<T>
class	CtExecutableImpl<R> The implementation for CtExecutable.
class	CtFieldImpl<T> The implementation for CtField.
class	CtImportImpl
class	CtInterfaceImpl<T>
class	CtMethodImpl<T> The implementation for CtMethod.
class	CtModuleImpl
class	CtModuleRequirementImpl
class	CtNamedElementImpl
class	CtPackageDeclarationImpl
class	CtPackageExportImpl
class	CtPackageImpl The implementation for CtPackage.
class	CtParameterImpl<T> The implementation for CtParameter.
class	CtProvidedServiceImpl
class	CtTypeImpl<T> The implementation for CtType.
class	CtTypeParameterImpl
class	CtUsedServiceImpl
class	InvisibleArrayConstructorImpl<T> This class is used to represent the constructor of an array when calling with an expression like

Uses of FactoryAccessor in spoon.support.reflect.reference

Classes in spoon.support.reflect.reference that implement FactoryAccessor

Modifier and Type	Class and Description
class	CtArrayTypeReferenceImpl<T>
class	CtCatchVariableReferenceImpl<T>
class	CtExecutableReferenceImpl<T>
class	CtFieldReferenceImpl<T>
class	CtIntersectionTypeReferenceImpl<T>
class	CtLocalVariableReferenceImpl<T> An implementation for CtLocalVariableReference.
class	CtModuleReferenceImpl
class	CtPackageReferenceImpl
class	CtParameterReferenceImpl<T>
class	CtReferenceImpl
class	CtTypeMemberWildcardImportReferenceImpl This class intends to be used only to represent the reference of a static import of all members of a type: import static org.junit.Assert.*;
class	CtTypeParameterReferenceImpl
class	CtTypeReferenceImpl<T>
class	CtUnboundVariableReferenceImpl<T> represents a reference to an unbound field (used when no full classpath is available
class	CtVariableReferenceImpl<T>
class	CtWildcardReferenceImpl