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 |
Modifier and Type | Class and Description |
---|---|
class |
CtUnresolvedImport |
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.
|
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
|
Modifier and Type | Class and Description |
---|---|
static class |
CtModelImpl.CtRootPackage |
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. |
Modifier and Type | Interface and Description |
---|---|
interface |
CompilationUnit
Deprecated.
|
Modifier and Type | Class and Description |
---|---|
static class |
NoSourcePosition.NullCompilationUnit |
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.
|
Modifier and Type | Class and Description |
---|---|
static class |
ModuleFactory.CtUnnamedModule |
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.
|
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.
|
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.
|
Modifier and Type | Class and Description |
---|---|
class |
CompilationUnitImpl
Implements a compilation unit.
|
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
|
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 |
Copyright © 2007–2021 Inria. All rights reserved.