All Classes

Class	Description
AbstractAnnotationProcessor<A extends 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.
AbstractAssert<T extends AbstractAssert<T,A>,A>	Base contract for all assertion objects: the minimum functionality that any assertion object should provide.
AbstractCtElementAssert<T extends AbstractCtElementAssert<T>>
AbstractCtPackageAssert<T extends AbstractCtPackageAssert<T>>
AbstractFileAssert<T extends AbstractFileAssert<T>>
AbstractFilter<T extends CtElement>	Defines an abstract filter based on matching on the element types.
AbstractManualProcessor	This class defines an abstract processor to be subclassed by the user for defining new manual processors.
AbstractNode	Represents a parameterized Pattern ValueResolver, which can be used to generate a zero, one or more copies of model using provided parameters to match zero, one or more instances of model and deliver a matching parameters
AbstractParallelProcessor<E extends CtElement>	AbstractParallelProcessor allows using multiple threads for concurrent processing with AbstractProcessor.
AbstractParameterInfo
AbstractPathElement<P extends CtElement,T extends CtElement>	Partial implementation for CtPathElement
AbstractProcessor<E extends CtElement>	This class defines an abstract processor to be subclassed by the user for defining new processors.
AbstractReferenceFilter<T extends CtReference>	This class defines an abstract reference filter that needs to be subclassed in order to define the matching criteria.
AbstractRenameRefactoring<T extends CtNamedElement>	abstract implementation of rename element refactoring
AbstractTemplate<T extends CtElement>	handles the well-formedness and helper methods of templates
AccessibleVariablesFinder	Find local variables catch, parameters, fields, super fields
Action	defines an action change on the model
ActionBasedChangeListener	notifies all change on the AST
ActionBasedChangeListenerImpl	This listener will propagate the change to the listener
AddAction<T>
AdvancedOptions<T extends AdvancedOptions<T>>
AllMethodsSameSignatureFunction	Returns all methods/lambdas with same signature in related inheritance hierarchies.
AllTypeMembersFunction	Expects CtType as input and produces all CtTypeMembers declared in input class or any super class or super interface.
AllTypeMembersFunction.Mode
AnnotationFactory	The CtAnnotationType sub-factory.
AnnotationFilter<E extends CtElement>	This filter matches all the elements annotated with a given annotation type.
AnnotationProcessingOptions<T extends AnnotationProcessingOptions<T>>
AnnotationProcessor<A extends Annotation,E extends CtElement>	This interface defines an annotation processor.
AnnotationRuntimeBuilderContext
Assert	Entry point for assertion methods for different data types.
ASTPair
AstParentConsistencyChecker
BinaryOperatorKind	This enumeration defines all the kinds of binary operators.
BlockTemplate	This class represents a template parameter that defines a void block statement directly expressed in Java (no returns).
BodyHolderSourcePosition	This interface represents the position of a Method or Type declaration in a source file.
BodyHolderSourcePositionImpl	This class represents the position of a Java program element in a source file.
ByteSerialization
CacheBasedConflictFinder	Caches some field and nested type names
CaseKind
CatchVariableReferenceFunction	This Query expects a CtCatchVariable as input and returns all CtCatchVariableReferences, which refers this input.
CatchVariableScopeFunction	This Query expects a CtCatchVariable as input and returns all CtElements, which are in visibility scope of that catch variable.
ChainOfMatchersImpl	Chain of RootNodes.
ChangeCollector	Listens on changes on the spoon model and remembers them
ChangeResolver	Helper which provides details about changes on provided `element`
Check
Child	This annotation defines a method that contains children of an element of the meta model.
ClassFactory	The CtClass sub-factory.
ClasspathOptions<T extends ClasspathOptions<T>>
ClassTypingContext	Helper class created from type X or reference to X.
CloneBuilder	Used to set all data in the cloned element.
CloneHelper	CloneHelper is responsible for creating clones of CtElement AST nodes including the whole subtree.
CloneVisitor	Used to clone a given element.
CodeFactory	This sub-factory contains utility methods to create code elements.
CollectionContext<T extends Collection<?>>
CollectionSourceFragment	SourceFragment of List or Set of ElementSourceFragments which belong to collection role.
CommentHelper	Computes source code representation of the Comment literal
CommentOffset
CompilationUnit	Deprecated.
CompilationUnitFactory	A factory to create some evaluation utilities on the Spoon metamodel.
CompilationUnitFilter	This interface is used by instances of SpoonModelBuilder to exclude particular CompilationUnits while generating a CtModel with SpoonModelBuilder.build(spoon.compiler.builder.JDTBuilder).
CompilationUnitImpl	Implements a compilation unit.
ComplianceOptions<T extends ComplianceOptions<T>>
CompositeFilter<T extends CtElement>	This class defines a composite filter, which can compose several filters together by using FilteringOperator.
CompoundSourcePosition	This interface represents the position of a program element like an expression in a source file.
CompoundSourcePositionImpl	This class represents the position of a named Java program element in a source file.
CompressionType	Different types of compressions used, e.g.
ComputedParameterInfo	Represents a parameter which is related to a value of another parameter.
ConceptKind	Represents categories of metamodel types
ConflictResolutionMode	Defines what happens when a RootNode has to be replaced by another RootNode, default in ConflictResolutionMode.FAIL.
ConstantNode<T>	Generates/Matches a copy of single template object
ConstructorFactory	The CtConstructor sub-factory.
ContainerKind	Represents a kind of data, which is used in an field or in a role in the Spoon metamodel.
Context	defines the context of an action
ContextBuilder
ContextBuilder.CastInfo
ContractVerifier	Verifies all contracts that should hold on any AST.
CoreFactory	This interface defines the core creation methods for the meta-model (to be implemented so that Spoon can manipulate other meta-model implementations).
CtAbstractBiScanner	Defines the core bi-scan responsibility.
CtAbstractImportVisitor	Provides an empty implementation of CtImportVisitor.
CtAbstractInvocation<T>	This code element defines an abstract invocation on a CtExecutable.
CtAbstractSwitch<S>	This code element defines an abstract switch (either switch statement or switch expression).
CtAbstractVisitor	Provides an empty implementation of CtVIsitor.
CtActualTypeContainer	This interface defines the capability related to binding generics (aka type parameters).
CtAnnotatedElementType	This enum specifies the element type which is annotated by the annotation
CtAnnotation<A extends Annotation>	This element represents an annotation on an element.
CtAnnotationFieldAccess<T>	This code element defines an access to a annotation parameter variable.
CtAnnotationFieldAccessImpl<T>
CtAnnotationImpl<A extends Annotation>	The implementation for CtAnnotation.
CtAnnotationMethod<T>	This element defines an annotation method declared in an annotation type.
CtAnnotationMethodImpl<T>	The implementation for CtAnnotationMethod.
CtAnnotationType<T extends Annotation>	This element defines an annotation type.
CtAnnotationTypeImpl<T extends Annotation>	The implementation for CtAnnotationType.
CtAnonymousExecutable	This element defines an anonymous executable block declaration in a class.
CtAnonymousExecutableImpl
CtArrayAccess<T,E extends CtExpression<?>>	This code element defines a one-dimensional array access.
CtArrayAccessImpl<T,V extends CtExpression<?>>
CtArrayRead<T>	This code element defines a read access to an array.
CtArrayReadImpl<T>
CtArrayTypeReference<T>	This interface defines a reference to an array.
CtArrayTypeReferenceImpl<T>
CtArrayWrite<T>	This code element defines a write access to an array.
CtArrayWriteImpl<T>
CtAssert<T>	This code element defines an assert clause.
CtAssertImpl<T>
CtAssignment<T,A extends T>	This code element defines an assignment.
CtAssignmentImpl<T,A extends T>
CtBFSIterator	A class to be able to iterate over the children elements in the tree of a given node, in breadth-first order.
CtBinaryOperator<T>	This interface defines a binary operator.
CtBinaryOperatorImpl<T>
CtBiScannerDefault	This visitor implements a deep-search scan on the model for 2 elements.
CtBlock<R>	This code element represents a block of code, that is to say a list of statements enclosed in curly brackets.
CtBlockImpl<R>
CtBodyHolder	This abstract code element defines an element, which contains a body
CtBreak	This code element defines a break statement.
CtBreakImpl
CtCase<S>	This code element defines a case within a switch-case.
CtCaseImpl<E>
CtCatch	This code element defines a catch of a try.
CtCatchImpl
CtCatchVariable<T>	This code element defines an exception variable in a catch.
CtCatchVariableImpl<T>
CtCatchVariableReference<T>	This interface defines a reference to CtCatchVariable.
CtCatchVariableReferenceImpl<T>
CtCFlowBreak	This abstract code element represents all the statements that break the control flow of the program.
CtClass<T>	This element represents a class declaration.
CtClassImpl<T>	The implementation for CtClass.
CtCodeElement	This interface is the root interface of the code elements.
CtCodeElementImpl
CtCodeSnippet	This interface represents snippets of source code that can be used in the AST to represent complex code without having to build the corresponding program model structure.
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.
CtCodeSnippetExpressionImpl<T>
CtCodeSnippetStatement	This element is a code snippet that must represent a statement and can thus be inserted in the program's model as is.
CtCodeSnippetStatementImpl
CtComment	This code element defines a comment Example: int x = 0; // a comment
CtComment.CommentType
CtCommentImpl
CtCompilationUnit	Defines a compilation unit.
CtCompilationUnit.UNIT_TYPE
CtCompilationUnitImpl	Implements a compilation unit.
CtConditional<T>	This code element defines conditional expressions using the ? (ternary expressions).
CtConditionalImpl<T>
CtConstructor<T>	This element defines a constructor declaration.
CtConstructorCall<T>	This code element represents a constructor call.
CtConstructorCallImpl<T>
CtConstructorImpl<T>
CtConsumableFunction<T>	Represents a function, as CtFunction.
CtConsumer<T>	The functional interface used to receive objects.
CtContinue	This code element defines the continue statement.
CtContinueImpl
CtDeprecatedRefactoring
CtDequeScanner	This class defines a scanner that maintains a scanning stack for contextual awareness.
CtDo	This code element defines a do loop.
CtDoImpl
CtElement	This interface is the root interface for the metamodel elements (any program element).
CtElementAssert
CtElementImpl	Contains the default implementation of most CtElement methods.
CtElementPathBuilder	This builder allow to create some CtPath from CtElements Created by nharrand on 21/02/2018.
CtEnum<T extends Enum<?>>	This element represents an enumeration declaration.
CtEnumImpl<T extends Enum<?>>
CtEnumValue<T>	Corresponds to one enum value specified in an enumeration.
CtEnumValueImpl<T>
CtExecutable<R>	This element represents an executable element such as a method, a constructor, or an anonymous block.
CtExecutableImpl<R>	The implementation for CtExecutable.
CtExecutableReference<T>	This interface defines a reference to a CtExecutable.
CtExecutableReferenceExpression<T,E extends CtExpression<?>>	This abstract code element defines an expression which represents an executable reference.
CtExecutableReferenceExpressionImpl<T,E extends CtExpression<?>>
CtExecutableReferenceImpl<T>
CtExpression<T>	This abstract code element defines a typed expression.
CtExpressionImpl<T>
CtExtendedModifier	Represents a modifier (eg "public").
CtField<T>	This element defines a field declaration.
CtFieldAccess<T>	This code element defines an access to a field variable (read and write)
CtFieldAccessImpl<T>
CtFieldImpl<T>	The implementation for CtField.
CtFieldRead<T>	This code element defines a read access to a field.
CtFieldReadImpl<T>
CtFieldReference<T>	This interface defines a reference to a CtField.
CtFieldReferenceImpl<T>
CtFieldWrite<T>	This code element defines a write access to a field.
CtFieldWriteImpl<T>
CtFor	This code element defines a for loop.
CtForEach	This code element defines a foreach statement.
CtForEachImpl
CtForImpl
CtFormalTypeDeclarer	This abstract element defines a declaration that accepts formal type parameters (aka generics), such as a CtType (class A<E>), CtMethod or CtConstructor.
CtFunction<T,R>	Abstraction for functions in the Spoon realm.
CtIf	This code element represents an if statement.
CtIfImpl
CtImport	This element represents an import declaration.
CtImportImpl
CtImportKind
CtImportVisitor	This interface defines the visitor for the different types of CtImport
CtInheritanceScanner	This class provides an abstract implementation of the visitor that allows its subclasses to scan the metamodel elements by recursively using their (abstract) supertype scanning methods.
CtInterface<T>	This element defines an interface declaration.
CtInterfaceImpl<T>
CtIntersectionTypeReference<T>	This interface defines a reference to an intersection type in generics or in casts.
CtIntersectionTypeReferenceImpl<T>
CtInvocation<T>	This code element defines a concrete invocation.
CtInvocationImpl<T>
CtIterator	A class to be able to iterate over the children elements in the tree of a given node, in depth-first order.
CtJavaDoc	This code element defines a javadoc comment Example:
CtJavaDocImpl
CtJavaDocTag	This code element defines a javadoc tag Example:
CtJavaDocTag.TagType	Define the possible type for a tag
CtJavaDocTagImpl
CtLabelledFlowBreak	This abstract code element represents all the statements that break the control flow of the program and which can support a label.
CtLambda<T>	This code element represents the creation of a lambda.
CtLambdaImpl<T>
CtLineElementComparator	Comparator of compile-time elements.
CtLiteral<T>	This code element defines a literal value (an int, a string, etc).
CtLiteralImpl<T>
CtLocalVariable<T>	This code element defines a local variable definition (within an executable body).
CtLocalVariableImpl<T>
CtLocalVariableReference<T>	This interface defines a reference to CtLocalVariable.
CtLocalVariableReferenceImpl<T>	An implementation for CtLocalVariableReference.
CtLoop	This abstract code element defines a loop.
CtLoopImpl
CtMethod<T>	This element defines a method declaration.
CtMethodImpl<T>	The implementation for CtMethod.
CtModel	represents a Java program, modeled by a set of compile-time (Ct) objects where each object is a program element (for instance, a CtClass represents a class).
CtModelImpl
CtModelImpl.CtRootPackage
CtModifiable	This interface defines an element that accepts modifiers.
CtModifierHandler
CtModule	Represents a Java module as defined in Java 9.
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.
CtModuleImpl
CtModuleReference	Represents a reference to a CtModule
CtModuleReferenceImpl
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.
CtModuleRequirement.RequiresModifier
CtModuleRequirementImpl
CtMultiTypedElement	Defined an element with several types.
CtNamedElement	Declares an element that has a name (a class, a method, a variable, etc).
CtNamedElementImpl
CtNamedPathElement	A CtPathElement that match on CtNamedElement#getSimpleName
CtNewArray<T>	This code element defines the inline creation of a new array.
CtNewArrayImpl<T>
CtNewClass<T>	This code element represents the creation of a anonymous class.
CtNewClassImpl<T>
CtOperatorAssignment<T,A extends T>	This code element defines an self-operated assignment such as += or *=.
CtOperatorAssignmentImpl<T,A extends T>
CtPackage	This element defines a package declaration.
CtPackageAssert
CtPackageDeclaration	This element represents an package declaration.
CtPackageDeclarationImpl
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.
CtPackageExportImpl
CtPackageImpl	The implementation for CtPackage.
CtPackageReference	This interface defines a reference to a CtPackage.
CtPackageReferenceImpl
CtParameter<T>	This element defines an executable parameter declaration.
CtParameterImpl<T>	The implementation for CtParameter.
CtParameterReference<T>	This interface defines a reference to a CtParameter of a method.
CtParameterReferenceImpl<T>
CtParameterRemoveRefactoring	Removes target CtParameter from the parent target CtExecutable and from all overriding/overridden methods of related type hierarchies and from all lambda expressions (if any) implementing the modified interface.
CtPath	A CtPath allows to define the path to a CtElement in the Spoon model, eg ".spoon.test.path.Foo.foo#body#statement[index=0]"
CtPathBuilder	This builder allow to create some CtPath.
CtPathElement<P extends CtElement,T extends CtElement>	A single path element from a CtPath.
CtPathException	This exception is throw when there are errors during a CtPath building or evaluation.
CtPathImpl	Default implementation for a CtPath
CtPathStringBuilder	Created by nicolas on 27/08/2015.
CtProvidedService	Represents a provided service in a CtModule.
CtProvidedServiceImpl
CtQuery	CtQuery represents a query, which can be used to traverse a spoon model and collect children elements in several ways.
CtQueryable	Represents an object on which one can make queries.
CtQueryAware	Expert-only capability interface so as to write advanced CtFunction and Filter that need to access the state of the top-level CtQuery instance containing the function to be evaluated.
CtQueryImpl	The facade of CtQuery which represents a query bound to the CtElement, which is the constant input of this query.
CtRefactoring	Defines basic contract of all refactoring implementations. Contract: to process a required refactoring. Usage:
CtReference	This is the root interface for named program element references.
CtReferenceImpl
CtRenameGenericVariableRefactoring	Spoon model that can refactor any type of variable (method parameters, local variables, field variables.
CtRenameLocalVariableRefactoring	Spoon model refactoring function which renames `target` local variable to `newName` This refactoring will throw RefactoringException if the model would be not consistent after rename to new name.
CtRenameRefactoring<T extends CtNamedElement>	The kind of refactoring, which renames a `target` element to the `newName` Usage:
CtReturn<R>	This code element represents a return statement.
CtReturnImpl<R>
CtRHSReceiver<A>	Represents the right hand side of an assignment See CtAssignment, CtLocalVariable, CtField
CtRole	Identifies the roles of attributes of spoon model.
CtRolePathElement	A CtPathElement that define some roles for matching.
CtScanner	This visitor implements a deep-search scan on the model.
CtScannerFunction	Returns all children of an element.
CtScannerListener	Responsible for performing an action when a scanner enters/exits a node while scanning the AST.
CtShadowable	A shadow element is an element that is in the Spoon model, but does not exist in the actual source code.
CtStatement	This abstract code element represents all the statements, which can be part of a block.
CtStatementImpl
CtStatementList	This code element represents a list of statements.
CtStatementListImpl<R>
CtSuperAccess<T>	This code element defines an access to super.
CtSuperAccessImpl<T>
CtSwitch<S>	This code element defines a switch statement.
CtSwitchExpression<T,S>	This code element defines a switch expression.
CtSwitchExpressionImpl<T,S>
CtSwitchImpl<S>
CtSynchronized	This code element defines a synchronized statement.
CtSynchronizedImpl
CtTargetedExpression<T,E extends CtExpression<?>>	This abstract code element defines an expression which contains a target expression.
CtTargetedExpressionImpl<E,T extends CtExpression<?>>
CtTextBlock	This code element defines a Text Block String Literal.
CtTextBlockImpl
CtThisAccess<T>	This code element defines an access to this.
CtThisAccessImpl<T>
CtThrow	This code element defines a throw statement.
CtThrowImpl
CtTry	This code element defines a try statement.
CtTryImpl
CtTryWithResource	This code element defines a try with resource statement.
CtTryWithResourceImpl
CtType<T>	This abstract element defines a super-type for classes and interfaces, which can declare methods.
CtTypeAccess<A>	This code element represents a type reference usable as an expression.
CtTypeAccessImpl<A>
CtTypedElement<T>	This abstract element defines a typed element.
CtTypedNameElement<P extends CtElement,T extends CtElement>	spoon.reflect.path.impl.CtPathElement that match on CtNamedElement
CtTypeImpl<T>	The implementation for CtType.
CtTypeInformation	Returns information that can be obtained both at compile-time and run-time For CtElement, the compile-time information is given For CtTypeReference, the runtime information is given (using the Reflection API)
CtTypeMember	This interface represents a member of a class (field, method, nested class or static/instance initializer).
CtTypeMemberWildcardImportReference	This interface defines a import reference to all static type members of a type. Example: somePackage.Type.*;
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.*;
CtTypeParameter	This element defines a declaration of a type parameter (aka generics).
CtTypeParameterImpl
CtTypeParameterReference	This interface defines a reference to a type parameter (aka generics).
CtTypeParameterReferenceImpl
CtTypeReference<T>	This interface defines a reference to a CtType or sub-type.
CtTypeReferenceImpl<T>
CtUnaryOperator<T>	This code element represents a unary operator.
CtUnaryOperatorImpl<T>
CtUnboundVariableReference<T>	This interface defines a reference to an unbound CtVariable.
CtUnboundVariableReferenceImpl<T>	represents a reference to an unbound field (used when no full classpath is available
CtUnresolvedImport
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.
CtUsedServiceImpl
CtVariable<T>	This abstract element defines a variable declaration.
CtVariableAccess<T>	This code element defines an access to a variable (read and write).
CtVariableAccessImpl<T>
CtVariableRead<T>	This code element defines an read access to a variable.
CtVariableReadImpl<T>
CtVariableReference<T>	This interface defines a reference to a CtVariable or sub-type.
CtVariableReferenceImpl<T>
CtVariableWrite<T>	This code element defines a write to a variable.
CtVariableWriteImpl<T>
CtVisitable	Define a visitable element in spoon.
CtVisitor	This interface defines the visitor for the Spoon metamodel, as defined in spoon.reflect.declaration, spoon.reflect.code, and spoon.reflect.reference.
CtWhile	This code element defines a while loop.
CtWhileImpl
CtWildcardReference	Represents a wildcard in generic type annotations, i.e.
CtWildcardReferenceImpl
CtYieldStatement	This code element defines a yield statement.
CtYieldStatementImpl	CtYieldStatementImpl
DeclarationSourcePosition	Represents the position of a program element in a source file in an immutable manner.
DeclarationSourcePositionImpl	This class represents the position of a Java program element in a source file.
DeepRepresentationComparator	Compares based on a toString representation.
DefaultCoreFactory	This class implements a default core factory for Spoon's meta-model.
DefaultGenerator	Drives generation process
DefaultImportComparator	Defines order of imports: 1) imports are ordered alphabetically 2) static imports are last
DefaultJavaPrettyPrinter	A visitor for generating Java code from the program compile-time model.
DefaultOutputDestinationHandler	Default behavior for the destination of the spoon.
DefaultSourceFragmentPrinter	A default dumb implementation of SourceFragmentPrinter, which only prints the given PrinterEvent.
DefaultTokenWriter	Implementation of TokenWriter, which writes all tokens to PrinterHelper
DeleteAction<T>	defines the delete action
DeleteAllAction<T>	defines the delete all action.
DerivedProperty	Tells that a metamodel property is derived, ie computed from the value of another property.
DirectReferenceFilter<T extends CtReference>	This simple filter matches all the references to a given element by using reference equality.
EarlyTerminatingScanner<T>	Extends CtScanner, to support early termination of scanning process and scan listeners.
ElementNode	Generates/Matches a copy of a single CtElement AST node with all it's children (whole AST tree of the root CtElement)
ElementPrinterEvent	Represents an action of Printer, which prints whole element
ElementPrinterHelper
ElementSourceFragment	Represents a part of source code of an CtElement It is connected into a tree of ElementSourceFragments.
EmptyClearableList<E>
EmptyClearableSet<E>
EmptyIterator<E>
EmptyModelChangeListener	is the listener that creates the action on the model.
EncodingProvider
EnumFactory	The CtEnum sub-factory.
Environment	This interface represents the environment in which Spoon is launched - accessible through Factory.getEnvironment().
Environment.PRETTY_PRINTING_MODE	Drives how the model is pretty-printed to disk, or when CtElement.prettyprint() is called
EqualsChecker
EqualsVisitor	Used to check equality between an element and another one.
EvalFactory	A factory to create some evaluation utilities on the Spoon metamodel.
EvalHelper
ExecutableFactory	The CtExecutable sub-factory.
ExecutableReferenceFilter	This filter matches all the CtExecutableReference referencing defined one or more CtExecutables.
ExecutableRuntimeBuilderContext
Experimental	Tells that a type has recently been introduced and may be subject to non-backward compatible changes without deprecation.
ExpressionTemplate<T>	This class represents an expression template parameter expressed in Java.
ExtensionTemplate	Inserts all the methods, fields, constructors, initialization blocks (if target is a class), inner types, and super interfaces (except Template) from a given template by substituting all the template parameters by their values.
Factory	Provides the sub-factories required by Spoon.
FactoryAccessor	This interface represents an object that can access the meta-model factory.
FactoryCompilerConfig
FactoryImpl	Implements Factory
FieldAccessFilter	This simple filter matches all the accesses to a given field.
FieldFactory	The CtField sub-factory.
FieldReferenceFunction	This Query expects a CtField as input and returns all CtFieldReferences, which refers this input.
FieldScopeFunction	This Query expects a CtField as input and returns all CtElements, which are in visibility scope of that field.
FileAssert
FileCompilerConfig
FileGenerator<T extends CtElement>	This interface should be implemented by processing tasks that generate new files as processing results.
FileSystemFile
FileSystemFolder
Filter<T extends CtElement>	This interface defines a filter for program elements.
FilteringFolder	A filtering resource, see https://github.com/INRIA/spoon/issues/877
FilteringOperator	This enumeration defines the possible composition operators for filters.
FineModelChangeListener	Can be subclassed by clients who want to be notified on all changes in AST nodes
FixedOrderBasedOnFileNameCompilationUnitComparator
FluentLauncher	FluentLauncher provides a different, fluent interface for the launcher class.
ForceFullyQualifiedProcessor	Forces fully qualified identifiers by making many elements explicit (by calling setImplicit(false)).
ForceImportProcessor	Marks all types references as implicit so all types will get imported.
ForEachNode	Pattern node of multiple occurrences of the same model, just with different parameters.
Generator	Generates code from patterns.
GenericTypeAdapter	Provides adapting of generic types from one scope to another scope.
HashcodeVisitor	Responsible for computing CtElement.hashCode().
ImmutableMap	An immutable map.
ImmutableMapImpl	Internal class only, not in the public API.
ImportCleaner	Updates list of import statements of compilation unit following CtElement.isImplicit().
ImportConflictDetector	Detects conflicts needed to be required be a fully-qualified name.
ImportScanner	Used to compute the imports required to write readable code with no fully qualified names.
ImportScannerImpl	A scanner that calculates the imports for a given model.
IncrementalLauncher	Create a Spoon launcher for incremental build
IndentationDetector	Utility class for detecting the indentation style used in a compilation unit.
InlinedStatementConfigurator	Builds inline statements of Pattern For example if the `for` statement in this pattern model
InlineNode	Represents a kind of RootNode, whose AST statements are understood as pattern statements.
InlinePartialEvaluator	Simplifies an AST inline based on VisitorPartialEvaluator (wanring: the nodes are changed).
InterfaceFactory	The CtInterface sub-factory.
Internal	Tells that a class or method is not in the public API (even if it has Java visibility "public") Required because package-visibility is too coarse-grained.
InvalidClassPathException
InvalidReplaceException	Thrown when replacing of element by another element is not possible
InvisibleArrayConstructorImpl<T>	This class is used to represent the constructor of an array when calling with an expression like
InvocationFilter	This simple filter matches all the accesses to a given executable or any executable that overrides it.
Javadoc	The structured content of a single Javadoc comment.
JavadocBlockTag	A block tag.
JavadocDescription	A javadoc text, potentially containing inline tags.
JavadocDescriptionElement	An element of a description: either an inline tag or a piece of text.
JavadocInlineTag	An inline tag contained in a Javadoc description.
JavadocInlineTag.Type	The type of tag: it could either correspond to a known tag (code, docRoot, etc.) or represent an unknown tag.
JavadocSnippet	A piece of text inside a Javadoc description.
JavaIdentifiers	This enum defines the Java keywords and some helper method to determine if some strings are Java identifiers.
JavaOutputProcessor	A processor that generates compilable Java source files from the meta-model.
JavaReflectionTreeBuilder	Builds Spoon model from class file using the reflection api.
JDTBasedSpoonCompiler	Main class of Spoon to build the model.
JDTBatchCompiler
JDTBuilder	Helper to build arguments for the JDT compiler.
JDTBuilderImpl
JDTCommentBuilder	The comment builder that will insert all element of a CompilationUnitDeclaration into the Spoon AST
JDTConstants	Extracts a subset of constants as defined in TypeConstants, since this class is only meant for internal use.
JDTSnippetCompiler
JDTTreeBuilder	A visitor for iterating through the parse tree.
JDTTreeBuilderHelper
LambdaFilter	This filter matches all the CtLambda elements, which implements defined interface(s)
Launcher	This class implements an integrated command-line launcher for processing programs at compile-time using the JDT-based builder (Eclipse).
Level	Enum for representing logging levels.
LexicalScope	Represents that a lexical scope in the language Note that scopes are changing after variable declaration.
LexicalScopeScanner	A CtScanner which provides current lexical scope of currently scanned AST node.
LineFilter	This filter matches all elements that can be considered as line of code (e.g.
ListContext	defines a list context
ListOfNodes	List of RootNodes.
ListParameterInfo
ListPrinter	Helper which assures consistent printing of lists prefixed with `start`, separated by `separator` and suffixed by `end`. If there is no item in the list then it prints `start` and then `end` If there is one item in the list then it prints `start`, item and then `end` If there is more then one items in the list then it prints `start`, items separated by `separator` and then `end`
LiteralBase
Local	This annotation should be placed on templates' members to indicate that they are local elements of the template class.
LocalVariableReferenceFunction	This mapping function expects a CtLocalVariable as input and returns all CtLocalVariableReferences, which refers this input.
LocalVariableScopeFunction	This Query expects a CtLocalVariable as input and returns all CtElements, which are in visibility scope of that local variable.
LovecraftException	"It was from the artists and poets that the pertinent answers came" In Spoon, we do believe that poetry has a place in software.
MapContext<K,V>	defines the map context
MapEntryNode	Represents a ValueResolver of one Map.Entry
MapParameterInfo	A kind of ParameterInfo which returns value by the named parameter From a container of type ImmutableMap or Map
MapUtils
Match	Represents a single match of Pattern
Matchers	A container of RootNodes.
MatchingScanner	Represents a Match of TemplateMatcher
MavenLauncher	Create a Spoon launcher from a maven pom file
MavenLauncher.SOURCE_TYPE	The type of source to consider in the model
Metamodel	Represents the Spoon metamodel (incl.
MetamodelConcept	Represents a concept of the Spoon metamodel (eg CtClass).
MetamodelProperty	Represents a property of the Spoon metamodel.
MetamodelPropertyField	Tells that a field is a property of the metamodel For instance CtNamedElementImpl.getSimpleName() is the property name of CtNamedElement
MethodCallState	This class is for the call state of a method.
MethodFactory	The CtMethod sub-factory.
MethodInvocationSearch	Class for creating a mapping from CtExecutable to all known calls from fields and methods.
MethodTypingContext	For the scope method or constructor and super type hierarchy of it's declaring type, it is able to adapt type parameters.
MMMethod	Represents a method used to get or set a MetamodelProperty of a MetamodelConcept.
MMMethodKind	Represents the type of metamodel method.
ModelBuildingException	thrown when the Spoon model of a program cannot be built
ModelConsistencyChecker	This scanner checks that a program model is consistent with regards to the parent elements (children must have the right parent).
ModelElementContainerDefaultCapacities	Recommended default capacities for containers (primarily ArrayList) of AST model elements.
ModelList<T extends CtElement>	The implementation of the List, which is used by Spoon model objects.
ModelSet<T extends CtElement>	The implementation of the Set, which is used by Spoon model objects.
ModelStreamer	This interface defines the protocol to save and load a factory and it's associated model through output and input streams.
ModelUtils
ModificationStatus	represents whether a SourceFragment has been modified, and should be reprinted as is or with the normal pretty-printer
ModifierKind	Represents a modifier on the declaration of a program element such as a class, method, or field.
ModuleFactory
ModuleFactory.CtUnnamedModule
MutableTokenWriter	TokenWriter which simply delegates to DefaultTokenWriter with the decorator pattern, until MutableTokenWriter.setMuted(boolean) is called with true Then all tokens are ignored.
NamedElementFilter<T extends CtNamedElement>	Filters elements by name and by type (for instance to find a method).
NameFilter<T extends CtNamedElement>	Filters elements by name (for instance to find a method).
NoSourcePosition	This class represents the position of a program element in a source file.
NoSourcePosition.NullCompilationUnit
ObjectContext
Options<T extends Options<T>>
OutputDestinationHandler
OutputType	Types of output.
OverriddenMethodFilter	Gets all overridden method from the method given.
OverriddenMethodQuery	Gets all overridden method from the method given.
OverridingMethodFilter	Gets all overriding method from the method given.
PackageFactory	The CtPackage sub-factory.
PackageRuntimeBuilderContext
Parameter	This annotation should be placed on templates' fields or methods to indicate that they represent template parameters.
ParameterComputer	Computes a value of ComputedParameterInfo I - type of input value O - type of computed value
ParameterInfo	Represents the parameter of Pattern defines acceptable value of parameter value during matching.
ParameterNode	Represents pattern model variable Delivers/Matches 0, 1 or more values of defined parameter.
ParameterReferenceFunction	This Query expects a CtParameter as input and returns all CtParameterReferences, which refers this input.
Parameters	This class defines an API to manipulate template parameters.
ParameterScopeFunction	This Query expects a CtParameter as input and returns all CtElements, which are in visibility scope of that parameter.
Parent	This annotation defines a method that returns the parent of an element of the meta model.
ParentExiter
ParentFunction	This Function expects a CtElement as input and returns all parents of this element.
ParentNotInitializedException	This exception is thrown when the parent of an element has not been correctly initialized.
PartialEvaluator	This interface defines a simple partial evaluator on the Spoon Java model.
PartialSourcePositionImpl	This class intends to create a source position containing only a compilation unit.
Pattern	Represents a pattern for matching code.
PatternBuilder	The master class to create a Pattern instance.
PatternBuilderHelper	Utility class to select parts of AST to be used as a model of a PatternBuilder.
PatternParameterConfigurator	Used to define pattern parameters.
PatternParameterConfigurator.ParameterElementPair
PatternPrinter	Generates the source code corresponding to a Pattern's RootNode
PositionBuilder	Created by bdanglot on 07/07/16.
PotentialVariableDeclarationFunction	This mapping function searches for all CtVariable instances, which might be a declaration of an input CtElement.
PrettyPrinter	This interface defines the pretty printers.
PrimitiveMatcher	Defines API of a primitive matcher - matcher for single target object
PrinterEvent	Represents an action of PrettyPrinter
PrinterHelper	Supports configurable printing of text with indentations and line and column counting
PrintingContext
ProcessingManager	The processing manager defines the API to process a program model of a given Factory with a set of processors.
ProcessingVisitor	This visitor implements the code processing engine.
ProcessInterruption	This exception is used to interrupt a processor during its processing.
Processor<E extends CtElement>	This interface defines a generic code processor.
ProcessorProperties	An interface to retrieve processor properties.
ProcessorPropertiesImpl
ProcessorUtils
ProgressLogger
Property	This annotation shall be used on processor fields to declare them as being properties (for configuration).
PropertyGetter	Specifies that a method is an official metamodel getter in the Spoon metamodel.
PropertySetter	Specifies that a method is an official metamodel setter in the Spoon metamodel.
QualifiedNameBasedSortedSet<E extends CtElement>	The set properties of this set are based on the qualified name of the element inserted.
QualifiedNameComparator	compares based on names (with a preference for qualified names if available)
Quantifier	Defines a matching strategy for pattern parameters, default is Quantifier.GREEDY.
Query	This class provides some useful methods to retrieve program elements and reference through a CtScanner-based deep search.
QueryFactory	A factory to create some queries on the Spoon metamodel.
QueryFailurePolicy	Use in CtQuery.failurePolicy(QueryFailurePolicy) to define how to handle failure
QueueProcessingManager	This processing manager applies the processors one by one from the given root element.
Refactoring	Contains all methods to refactor code elements in the AST.
RefactoringException	Thrown when required refactoring would cause model inconsistency
ReferenceBuilder
ReferenceTypeFilter<T extends CtReference>	This simple filter matches all the references of a given type.
RegexFilter<E extends CtElement>	Filters elements with a regular expression on the element's code.
RepeatableMatcher	Defines API of a repeatable matcher.
ReplaceListener<T extends CtElement>	Interface for the AST node replacement infrastructure.
ReplaceListListener<T extends Collection>
ReplaceMapListener<T extends Map>
ReplacementVisitor	Used to replace an element by another one.
ReplaceSetListener<T extends Set>
ResultHolder<T>	Container for single or multiple values of required type
ResultHolder.Multiple<T>	Container of multiple values of required type
ResultHolder.Single<T>	Container of single value of required type
ReturnOrThrowFilter	This simple filter matches all the occurrences of a return or a throw statement (end of execution flow).
RoleHandler	Enables client code to get and set a field based on a role for a CtElement.
RoleHandlerHelper	Provides a RoleHandler implementation for the pair of CtElement implementation and CtRole The returned RoleHandler can be then used to manipulate value of attribute represented by CtRole on the CtElement instance
Root	This annotation defines an element as Root of the meta model.
RootNode	Represents a parameterized Pattern ValueResolver, which can be used to generate a zero, one or more copies of model using provided parameters to match zero, one or more instances of model and deliver a matching parameters
RtHelper	This class is a helper for runtime reflection.
RtMethod
RtParameter	To be compatible with Java 6, RtParameter has been created from the Parameter class in Java 8.
RuntimeBuilderContext
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.
SameFilter	Finds the element given in parameter, useful for checking if an element is in an ancestor.
ScanningMode	Defines how a CtScannerListener drives the scanning of EarlyTerminatingScanner
SerializationModelStreamer	This class provides a regular Java serialization-based implementation of the model streamer.
SetContext
SetParameterInfo
SiblingsFunction	visits siblings of input element.
SiblingsFunction.Mode	Defines visiting mode
SignatureBasedSortedSet<E extends CtExecutable<?>>	maintains unicity with method signatures
SignatureComparator	Compares executables (method, executable-references) based on a signature.
SignaturePrinter	Responsible for computing signatures for elements where a signature exists (CtType, CtMethod and CtPackage).
SimpleNameOfTypeReferenceParameterComputer	a ParameterComputer which computes simpleName of CtTypeReference
SniperJavaPrettyPrinter	PrettyPrinter implementation, which copies as much as possible from the origin sources and tries to only print the changed elements.
SnippetCompilationError
SnippetCompilationHelper	Helper class for working with snippets
SortedList<E>
SourceFragment	Represents a part of source code.
SourceFragmentContextList	Handles printing of changes of the ordered list of elements.
SourceFragmentContextNormal	Knows how to print modified CtElement by the way that origin formatting is kept as much as possible.
SourceFragmentCreator	A ChangeCollector, which builds a tree of ElementSourceFragments of CompilationUnit of the modified element lazily just before the element is changed
SourceFragmentPrinter	An object that knows how to print PrinterEvent
SourceOptions<T extends SourceOptions<T>>
SourcePosition	This interface represents the position of a program element in a source file.
SourcePositionHolder	This interface represents an element which knows its position in a source file.
SourcePositionImpl	This immutable class represents the position of a Java program element in a source file.
SpoonAPI	Is the core entry point of Spoon.
SpoonClassNotFoundException	Spoon-specific ClassNotFoundException (mostly encapsulates a ClassNotFoundException or a NoClassDefFoundError as a runtime exception)
SpoonException	is a generic runtime exception for Spoon
SpoonFile	This interface represents files that can be used as resources for the Spoon compiler.
SpoonFolder	A Spoon resource that represents a folder.
SpoonifierVisitor	Visitor that generates factory calls to recreate the AST visited.
SpoonModelBuilder	Responsible for building a spoon model from Java source code.
SpoonModelBuilder.InputType	The types of compilable elements FILES - compiles the java files from the file system, which were registered by SpoonModelBuilder.addInputSource(File) and SpoonModelBuilder.addTemplateSource(File) CTTYPES - compiles virtual java files, which are dynamically generated from the all top level classes of the CtModel by DefaultJavaPrettyPrinter
SpoonModelTree
SpoonObjectFieldsTable
SpoonPom
SpoonProgress	is the interface to follow the progress of the creation of the Spoon model.
SpoonProgress.Process
SpoonResource	This interface defines generic resources that are used by SpoonModelBuilder in the Java compilation process.
SpoonResourceHelper	This class defines a helper for manipulating resources.
SpoonTagger	Creates an empty class spoon.Spoon
SpoonTreeBuilder
StandardEnvironment	This class implements a simple Spoon environment that reports messages in the standard output stream (Java-compliant).
StatementTemplate	This class represents a template parameter that defines a statement list directly expressed in Java (no returns).
StringNode	Delivers single String value, which is created by replacing string markers in constant String template by String value of appropriate parameter.
SubFactory	This class is the superclass for all the sub-factories of Factory.
SubInheritanceHierarchyFunction	Expects a CtTypeInformation as input and produces all sub classes and sub interfaces recursively. The output is produced in arbitrary order.
SubInheritanceHierarchyResolver	Expects a CtPackage as input and upon calls to forEachSubTypeInPackage produces all sub classes and sub interfaces, which extends or implements super type(s) provided by call(s) of SubInheritanceHierarchyResolver.addSuperType(CtTypeInformation) and stored as `targetSuperTypes`. The repeated processing of this mapping function on the same input returns only newly found sub types.
Substitution	This class defines the substitution API for templates (see Template).
SubstitutionRequestProvider	Maps AST model object to the RootNode
SubtypeFilter	Matches all CtType elements, which are sub type of SubtypeFilter.superType Matches the input `superType` too.
SuperInheritanceHierarchyFunction	Expects a CtTypeInformation as input and produces all super classes and super interfaces recursively. The output is produced in following order: input type.
SuperInheritanceHierarchyFunction.DistinctTypeListener	Implementation of CtScannerListener, which is used to assure that each interface is visited only once.
SwitchNode	List of conditional cases {code} if (a) { ...
Template<T extends CtElement>	A template code is simply a piece of code that uses a TemplateParameter's instance.
TemplateException	This runtime exception can be throws when something wrong occurs in template operations such as loading, substitution, and matching.
TemplateMatcher	This class defines an engine for matching a template to pieces of code.
TemplateParameter<T>	This interface defines a typed template parameter.
TobeMatched	Describes what next has to be matched.
TokenPrinterEvent	Represents an action of Printer, which prints a token
TokenSourceFragment	a SourceFragment of some primitive String token, like separator, operator, whitespace, ...
TokenType	Type of TokenSourceFragment token.
TokenWriter	Responsible for writing a token while pretty-printing.
TokenWriterProxy	Wraps a `tokenWriter` by an implementation which intercepts all TokenWriter writeXxx(String) calls and calls TokenWriterProxy.Listener.onTokenWriterWrite(TokenType, String, CtComment, Runnable) where Runnable can be used to invoke same event on the wrapped TokenWriter
TokenWriterProxy.Listener	Listens for each call of TokenWriter
TraversalStrategy	This enumeration defines the traversal strategies available for a processor.
TreeBuilderRequestor
TypeFactory	The CtType sub-factory.
TypeFilter<T extends CtElement>	This simple filter matches all the elements of a given type.
TypeReferenceRuntimeBuilderContext
TypeReferenceScanner	A scanner that calculates the imports for a given model.
TypeRuntimeBuilderContext
UnaryOperatorKind	This enumeration defines all the kinds of unary operators.
UndefinedParameterException
UnsettableProperty	Tells that a metamodel property (ie a getter in metamodel interface) is unsettable because it does not make sense for a certain metamodel element.
UpdateAction<T>	defines the update action
ValueConvertor	Converts the individual parameter values to required type after substitution Converts the matching model values to parameter values during matching process
ValueConvertorImpl	Converts the individual parameter values to required type
VariableAccessFilter<T extends CtVariableAccess<?>>	This simple filter matches all the accesses to a given field.
VariableReferenceFunction	The mapping function, accepting CtVariable CtLocalVariable - local variable declared in body CtField - member field of an type CtParameter - method parameter CtCatchVariable - try - catch variable and returning all the CtVariableReference, which refers this variable
VariableRuntimeBuilderContext
VariableScopeFunction	The mapping function, accepting CtVariable CtLocalVariable - local variable declared in body CtParameter - method parameter CtCatchVariable - try - catch variable and returning all the CtElements, which exists in visibility scope of this variable.
VirtualFile
VirtualFolder
VisitorPartialEvaluator	Simplifies an AST by performing all operations that are statically known and changes the AST accordingly (eg "0+1" -> "1") This visitor implements a simple partial evaluator for the program compile-time metamodel.
ZipFile
ZipFolder