Uses of Interface
spoon.reflect.declaration.CtElement

Packages that use CtElement

Package	Description
spoon	This root package provides the default integrated launchers for Spoon program processing.
spoon.compiler	This package defines interfaces for Java file compilation with Spoon.
spoon.experimental	this is unstable code, subject to potential complete redesign, not only in snapshots but also in releases.
spoon.metamodel	Ready to go meta? This package contains classes that model the Spoon metamodel itself.
spoon.pattern
spoon.pattern.internal
spoon.pattern.internal.matcher
spoon.pattern.internal.node
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.eval	This package defines some evaluators for the Spoon meta-model.
spoon.reflect.factory	This package defines all the sub-factories for the Spoon meta-model.
spoon.reflect.meta.impl
spoon.reflect.path
spoon.reflect.path.impl
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.reflect.visitor.chain
spoon.reflect.visitor.filter	This package contains a set of useful filters when querying the model.
spoon.support	This package contains some default implementations for commonly used processing tasks.
spoon.support.comparator
spoon.support.compiler.jdt
spoon.support.gui
spoon.support.modelobs
spoon.support.modelobs.context
spoon.support.reflect	This package provides an implementation of the spoon.reflect package.
spoon.support.reflect.code
spoon.support.reflect.cu
spoon.support.reflect.declaration
spoon.support.reflect.eval
spoon.support.reflect.reference
spoon.support.sniper	This package provides support for the sniper mode: only the transformed part of classes is rewritten to disk.
spoon.support.sniper.internal
spoon.support.util
spoon.support.visitor
spoon.support.visitor.clone
spoon.support.visitor.equals
spoon.support.visitor.replace
spoon.template	This package defines a framework for well-typed pure-Java templates.
spoon.testing
spoon.testing.utils

Uses of CtElement in spoon

Methods in spoon with type parameters of type CtElement

Modifier and Type	Method and Description
<T extends CtElement> void	SpoonAPI.addProcessor(Processor<T> processor) Adds an instance of a processor.
<T extends CtElement> void	Launcher.addProcessor(Processor<T> processor)
<T extends CtElement> FluentLauncher	FluentLauncher.processor(java.lang.Iterable<Processor<T>> processors) Adds an instance of a processor.
<T extends CtElement> FluentLauncher	FluentLauncher.processor(Processor<T> processor) Adds an instance of a processor.

Methods in spoon that return types with arguments of type CtElement

Modifier and Type	Method and Description
protected java.util.List<Processor<? extends CtElement>>	Launcher.getProcessors() Gets the list of processors instance to be initially applied during the processing.

Methods in spoon with parameters of type CtElement

Modifier and Type	Method and Description
void	ContractVerifier.checkParentConsistency(CtElement element) public modifier for testing purpose only, not in the public API

Method parameters in spoon with type arguments of type CtElement

Modifier and Type	Method and Description
void	SpoonModelBuilder.process(java.util.Collection<Processor<? extends CtElement>> processors) Processes the Java model with the given processors.

Uses of CtElement in spoon.compiler

Methods in spoon.compiler that return types with arguments of type CtElement

Modifier and Type	Method and Description
FileGenerator<? extends CtElement>	Environment.getDefaultFileGenerator() Returns the default file generator for this environment (gives the default output directory for the created files).

Methods in spoon.compiler with parameters of type CtElement

Modifier and Type	Method and Description
void	Environment.report(Processor<?> processor, org.slf4j.event.Level level, CtElement element, java.lang.String message) Helper method called by a processor to report an error, warning or message as dictated by the severity parameter.

Method parameters in spoon.compiler with type arguments of type CtElement

Modifier and Type	Method and Description
void	Environment.setDefaultFileGenerator(FileGenerator<? extends CtElement> generator) Sets the default file generator for this environment.

Uses of CtElement in spoon.experimental

Classes in spoon.experimental that implement CtElement

Modifier and Type	Class and Description
class	CtUnresolvedImport

Methods in spoon.experimental with parameters of type CtElement

Modifier and Type	Method and Description
void	SpoonifierVisitor.enter(CtElement element)
void	SpoonifierVisitor.exit(CtElement element)

Uses of CtElement in spoon.metamodel

Methods in spoon.metamodel that return types with arguments of type CtElement

Modifier and Type	Method and Description
java.util.List<CtType<? extends CtElement>>	Metamodel.getAllInstantiableMetamodelInterfaces()

Method parameters in spoon.metamodel with type arguments of type CtElement

Modifier and Type	Method and Description
MetamodelConcept	Metamodel.getConcept(java.lang.Class<? extends CtElement> clazz)
static java.lang.String	Metamodel.getConceptName(java.lang.Class<? extends CtElement> conceptClass)

Uses of CtElement in spoon.pattern

Methods in spoon.pattern with type parameters of type CtElement

Modifier and Type	Method and Description
<T extends CtElement> java.util.List<T>	Generator.generate(ImmutableMap params) Utility method that provides the same feature as Generator.generate(Map), but with a ImmutableMap as parameter (a Spoon elegant utility type)
<T extends CtElement> java.util.List<T>	Generator.generate(java.util.Map<java.lang.String,java.lang.Object> params) Main method to generate a new AST made from substituting of parameters by the values in `params`

Methods in spoon.pattern that return CtElement

Modifier and Type	Method and Description
CtElement	Match.getMatchingElement()

Methods in spoon.pattern that return types with arguments of type CtElement

Modifier and Type	Method and Description
java.util.List<CtElement>	Match.getMatchingElements()
java.util.List<CtElement>	PatternBuilderHelper.getPatternElements()

Methods in spoon.pattern with parameters of type CtElement

Modifier and Type	Method and Description
PatternParameterConfigurator	PatternParameterConfigurator.byElement(CtElement... elements) Elements will be substituted by parameter value
PatternParameterConfigurator	PatternParameterConfigurator.byRole(CtRole role, CtElement... elements) Attribute defined by `role` of `element` will be substituted by parameter value
PatternParameterConfigurator.ParameterElementPair	PatternParameterConfigurator.ParameterElementPair.copyAndSet(CtElement element)
static PatternBuilder	PatternBuilder.create(CtElement... elems)
java.util.List<Match>	Pattern.getMatches(CtElement root) Finds all target program sub-trees that correspond to this pattern and returns them.

Method parameters in spoon.pattern with type arguments of type CtElement

Modifier and Type	Method and Description
static PatternBuilder	PatternBuilder.create(java.util.List<? extends CtElement> patternModel) Creates a PatternBuilder from the List of template elements
PatternBuilderHelper	PatternBuilderHelper.keepTypeMembers(Filter<? super CtElement> filter)

Constructors in spoon.pattern with parameters of type CtElement

Constructor and Description
ParameterElementPair(ParameterInfo parameter, CtElement element)

Constructor parameters in spoon.pattern with type arguments of type CtElement

Constructor and Description
PatternBuilder(java.util.List<? extends CtElement> template)

Uses of CtElement in spoon.pattern.internal

Methods in spoon.pattern.internal with type parameters of type CtElement

Modifier and Type	Method and Description
<T extends CtElement> java.util.List<T>	DefaultGenerator.generate(ImmutableMap params)
<T extends CtElement> java.util.List<T>	DefaultGenerator.generate(java.util.Map<java.lang.String,java.lang.Object> params)

Methods in spoon.pattern.internal with parameters of type CtElement

Modifier and Type	Method and Description
void	DefaultGenerator.applyGeneratedBy(CtElement generatedElement, java.lang.String genBy) Adds a Generated by comment to the javadoc of generatedElement
java.lang.String	DefaultGenerator.getGeneratedByComment(CtElement ele)

Uses of CtElement in spoon.pattern.internal.matcher

Methods in spoon.pattern.internal.matcher with parameters of type CtElement

Modifier and Type	Method and Description
void	MatchingScanner.scan(CtRole role, CtElement element)

Method parameters in spoon.pattern.internal.matcher with type arguments of type CtElement

Modifier and Type	Method and Description
void	MatchingScanner.scan(CtRole role, java.util.Collection<? extends CtElement> elements)
void	MatchingScanner.scan(CtRole role, java.util.Map<java.lang.String,? extends CtElement> elements)

Uses of CtElement in spoon.pattern.internal.node

Methods in spoon.pattern.internal.node with parameters of type CtElement

Modifier and Type	Method and Description
static ElementNode	ElementNode.create(CtElement element, java.util.Map<CtElement,RootNode> patternElementToSubstRequests) Creates an implicit ElementNode, which contains all non derived attributes of `element` and all it's children
protected void	ElementNode.generateSingleNodeAttributes(DefaultGenerator generator, CtElement clone, ImmutableMap parameters)
protected ImmutableMap	ElementNode.matchesRole(ImmutableMap parameters, CtElement target, MetamodelProperty mmField, RootNode attrNode)

Method parameters in spoon.pattern.internal.node with type arguments of type CtElement

Modifier and Type	Method and Description
static ElementNode	ElementNode.create(CtElement element, java.util.Map<CtElement,RootNode> patternElementToSubstRequests) Creates an implicit ElementNode, which contains all non derived attributes of `element` and all it's children
static ListOfNodes	ElementNode.create(java.util.List<?> objects, java.util.Map<CtElement,RootNode> patternElementToSubstRequests) Same like ElementNode.create(CtElement, Map) but with List of elements or primitive objects
static ListOfNodes	ElementNode.create(java.util.Map<java.lang.String,?> map, java.util.Map<CtElement,RootNode> patternElementToSubstRequests) Same like ElementNode.create(CtElement, Map) but with Map of String to elements or primitive objects
static ListOfNodes	ElementNode.create(java.util.Set<?> templates, java.util.Map<CtElement,RootNode> patternElementToSubstRequests) Same like ElementNode.create(CtElement, Map) but with Set of elements or primitive objects
RootNode	ElementNode.getOrCreateNodeOfRole(CtRole role, java.util.Map<CtElement,RootNode> patternElementToSubstRequests)

Constructors in spoon.pattern.internal.node with parameters of type CtElement

Constructor and Description
ElementNode(MetamodelConcept elementType, CtElement templateElement)

Uses of CtElement in spoon.processing

Classes in spoon.processing with type parameters of type CtElement

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	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.
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	Processor<E extends CtElement> This interface defines a generic code processor.

Methods in spoon.processing that return types with arguments of type CtElement

Modifier and Type	Method and Description
java.util.Set<java.lang.Class<? extends CtElement>>	Processor.getProcessedElementTypes() Gets all the element types than need to be processed.
java.util.Set<java.lang.Class<? extends CtElement>>	AbstractProcessor.getProcessedElementTypes()
java.util.Set<java.lang.Class<? extends CtElement>>	AbstractManualProcessor.getProcessedElementTypes() Invalid method in this context.

Methods in spoon.processing with parameters of type CtElement

Modifier and Type	Method and Description
boolean	AbstractManualProcessor.isToBeProcessed(CtElement candidate) Always returns false in this context.
void	ProcessingManager.process(CtElement element) Recursively processes a CtElement with this manager.
void	AbstractManualProcessor.process(CtElement element) Does nothing in this context.

Method parameters in spoon.processing with type arguments of type CtElement

Modifier and Type	Method and Description
protected void	AbstractProcessor.addProcessedElementType(java.lang.Class<? extends CtElement> elementType) Adds a processed element type.
protected void	AbstractManualProcessor.addProcessedElementType(java.lang.Class<? extends CtElement> elementType) Invalid method in this context.
void	ProcessingManager.process(java.util.Collection<? extends CtElement> elements) Recursively processes a collection of CtElements with this manager.
protected void	AbstractProcessor.removeProcessedElementType(java.lang.Class<? extends CtElement> elementType) Removes a processed element type.

Uses of CtElement in spoon.reflect

Classes in spoon.reflect that implement CtElement

Modifier and Type	Class and Description
static class	CtModelImpl.CtRootPackage

Methods in spoon.reflect with type parameters of type CtElement

Modifier and Type	Method and Description
<R extends CtElement> CtQuery	CtModelImpl.filterChildren(Filter<R> filter)
<E extends CtElement> java.util.List<E>	CtModelImpl.getElements(Filter<E> filter)
<E extends CtElement> java.util.List<E>	CtModel.getElements(Filter<E> filter) Returns all the model elements matching the filter.

Uses of CtElement in spoon.reflect.code

Subinterfaces of CtElement 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.

Methods in spoon.reflect.code with type parameters of type CtElement

Modifier and Type	Method and Description
<E extends CtElement> E	CtTypeAccess.setImplicit(boolean implicit) Calls CtTypeAccess.getAccessedType().setImplicit()

Uses of CtElement in spoon.reflect.cu

Subinterfaces of CtElement in spoon.reflect.cu

Modifier and Type	Interface and Description
interface	CompilationUnit Deprecated.

Uses of CtElement in spoon.reflect.cu.position

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

Modifier and Type	Class and Description
static class	NoSourcePosition.NullCompilationUnit

Uses of CtElement in spoon.reflect.declaration

Subinterfaces of CtElement 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	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.

Methods in spoon.reflect.declaration with type parameters of type CtElement

Modifier and Type	Method and Description
<E extends CtElement> E	CtElement.addAnnotation(CtAnnotation<? extends java.lang.annotation.Annotation> annotation) Add an annotation for this element
<E extends CtElement> E	CtElement.addComment(CtComment comment) Add a comment to the current element element.addComment(element.getFactory().Code().createComment("comment", CtComment.CommentType.INLINE)
<E extends CtElement> java.util.List<E>	CtElement.getAnnotatedChildren(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType) Gets the child elements annotated with the given annotation type's instances.
<E extends CtElement> java.util.List<E>	CtElement.getElements(Filter<E> filter) Returns all the children elements recursively matching the filter.
<P extends CtElement> P	CtElement.getParent(java.lang.Class<P> parentType) Gets the first parent that matches the given type.
<E extends CtElement> E	CtElement.getParent(Filter<E> filter) Gets the first parent that matches the filter.
<E extends CtElement> E	CtElement.putMetadata(java.lang.String key, java.lang.Object val) Saves metadata inside an Element.
<E extends CtElement> E	CtElement.removeComment(CtComment comment) Remove a comment
<E extends CtElement> void	CtElement.replace(java.util.Collection<E> elements) Replaces this element by several elements.
<E extends CtElement> E	CtElement.setAllMetadata(java.util.Map<java.lang.String,java.lang.Object> metadata) Saves a bunch of metadata inside an Element
<E extends CtElement> E	CtElement.setAnnotations(java.util.List<CtAnnotation<? extends java.lang.annotation.Annotation>> annotation) Sets the annotations for this element.
<E extends CtElement> E	CtElement.setComments(java.util.List<CtComment> comments) Set the comment list
<E extends CtElement> E	CtElement.setDocComment(java.lang.String docComment) Sets the text of the documentation ("javadoc") comment of this declaration.
<E extends CtElement> E	CtElement.setImplicit(boolean b) Sets this element to be implicit.
<E extends CtElement> E	CtElement.setParent(E parent) Manually sets the parent element of the current element.
<E extends CtElement> E	CtCompilationUnit.setParent(E parent)
<E extends CtElement> E	CtElement.setPosition(SourcePosition position) Sets the position in the Java source file.
<E extends CtElement> E	CtCompilationUnit.setPosition(SourcePosition position)
<E extends CtElement> E	CtElement.setPositions(SourcePosition position) Sets the position of this element and all its children element.
<E extends CtElement,T> E	CtElement.setValueByRole(CtRole role, T value) Sets a field according to a role.

Methods in spoon.reflect.declaration that return CtElement

Modifier and Type	Method and Description
CtElement	CtElement.clone() Clone the element which calls this method in a new object.
CtElement	CtAnnotation.getAnnotatedElement() Returns the element which is annotated by this annotation.
CtElement	CtElement.getParent() Gets the parent of current reference.
CtElement	CtCompilationUnit.getParent()

Methods in spoon.reflect.declaration that return types with arguments of type CtElement

Modifier and Type	Method and Description
java.lang.Iterable<CtElement>	CtElement.asIterable() Returns an Iterable instance of this CtElement, allowing for dfs traversal of its descendants.
java.util.Iterator<CtElement>	CtElement.descendantIterator() Returns an iterator over this CtElement's descendants.
java.util.List<CtElement>	CtElement.getDirectChildren()

Methods in spoon.reflect.declaration with parameters of type CtElement

Modifier and Type	Method and Description
static CtAnnotatedElementType	CtAnnotation.getAnnotatedElementTypeForCtElement(CtElement element)
boolean	CtElement.hasParent(CtElement candidate) Tells if the given element is a direct or indirect parent.
void	CtElement.replace(CtElement element) Replaces this element by another one.

Uses of CtElement in spoon.reflect.eval

Methods in spoon.reflect.eval with type parameters of type CtElement

Modifier and Type	Method and Description
<R extends CtElement> R	PartialEvaluator.evaluate(R element) Partially evaluates an element and all its sub-elements.

Uses of CtElement in spoon.reflect.factory

Classes in spoon.reflect.factory that implement CtElement

Modifier and Type	Class and Description
static class	ModuleFactory.CtUnnamedModule

Methods in spoon.reflect.factory with type parameters of type CtElement

Modifier and Type	Method and Description
<T extends CtElement> T	CoreFactory.clone(T element) Recursively clones a given element of the metamodel and all its child elements.

Methods in spoon.reflect.factory that return CtElement

Modifier and Type	Method and Description
CtElement	CoreFactory.create(java.lang.Class<? extends CtElement> klass) Creates an instance of the concrete metamodel class given as parameter.
CtElement	Factory.createElement(java.lang.Class<? extends CtElement> klass)
CtElement	FactoryImpl.createElement(java.lang.Class<? extends CtElement> klass)
CtElement	ModuleFactory.CtUnnamedModule.getParent()

Methods in spoon.reflect.factory with parameters of type CtElement

Modifier and Type	Method and Description
<A extends java.lang.annotation.Annotation> CtAnnotation<A>	AnnotationFactory.annotate(CtElement element, java.lang.Class<A> annotationType) Adds an annotation to an element.
<A extends java.lang.annotation.Annotation> CtAnnotation<A>	AnnotationFactory.annotate(CtElement element, java.lang.Class<A> annotationType, java.lang.String annotationElementName, java.lang.Object value) Creates/updates an element's annotation value.
<A extends java.lang.annotation.Annotation> CtAnnotation<A>	AnnotationFactory.annotate(CtElement element, CtTypeReference<A> annotationType) Adds an annotation to an element.
<A extends java.lang.annotation.Annotation> CtAnnotation<A>	AnnotationFactory.annotate(CtElement element, CtTypeReference<A> annotationType, java.lang.String annotationElementName, java.lang.Object value) Creates/updates an element's annotation value.

Method parameters in spoon.reflect.factory with type arguments of type CtElement

Modifier and Type	Method and Description
CtElement	CoreFactory.create(java.lang.Class<? extends CtElement> klass) Creates an instance of the concrete metamodel class given as parameter.
CtElement	Factory.createElement(java.lang.Class<? extends CtElement> klass)
CtElement	FactoryImpl.createElement(java.lang.Class<? extends CtElement> klass)

Uses of CtElement in spoon.reflect.meta.impl

Methods in spoon.reflect.meta.impl with parameters of type CtElement

Modifier and Type	Method and Description
static RoleHandler	RoleHandlerHelper.getRoleHandlerWrtParent(CtElement element)

Method parameters in spoon.reflect.meta.impl with type arguments of type CtElement

Modifier and Type	Method and Description
static RoleHandler	RoleHandlerHelper.getOptionalRoleHandler(java.lang.Class<? extends CtElement> targetClass, CtRole role)
static RoleHandler	RoleHandlerHelper.getRoleHandler(java.lang.Class<? extends CtElement> targetClass, CtRole role)
static java.util.List<RoleHandler>	RoleHandlerHelper.getRoleHandlers(java.lang.Class<? extends CtElement> targetClass)

Uses of CtElement in spoon.reflect.path

Methods in spoon.reflect.path with type parameters of type CtElement

Modifier and Type	Method and Description
<T extends CtElement> java.util.List<T>	CtPath.evaluateOn(CtElement... startNode) Search for elements matching this CtPatch from start nodes given as parameters.
<T extends CtElement> CtPathBuilder	CtPathBuilder.type(java.lang.Class<T> type, java.lang.String[]... args) Match on element of a given type.

Methods in spoon.reflect.path with parameters of type CtElement

Modifier and Type	Method and Description
<T extends CtElement> java.util.List<T>	CtPath.evaluateOn(CtElement... startNode) Search for elements matching this CtPatch from start nodes given as parameters.
CtPath	CtElementPathBuilder.fromElement(CtElement el) Build absolute path to a CtElement el.
CtPath	CtElementPathBuilder.fromElement(CtElement el, CtElement root) Build path to a CtElement el, from one of its parent.
CtRole	CtRole.getMatchingSubRoleFor(CtElement item)
CtPath	CtPath.relativePath(CtElement parent) Returns the path that is relative to the given element (subpath from it to the end of the path).

Uses of CtElement in spoon.reflect.path.impl

Classes in spoon.reflect.path.impl with type parameters of type CtElement

Modifier and Type	Class and Description
class	AbstractPathElement<P extends CtElement,T extends CtElement> Partial implementation for CtPathElement
class	AbstractPathElement<P extends CtElement,T extends CtElement> Partial implementation for CtPathElement
interface	CtPathElement<P extends CtElement,T extends CtElement> A single path element from a CtPath.
interface	CtPathElement<P extends CtElement,T extends CtElement> A single path element from a CtPath.
class	CtTypedNameElement<P extends CtElement,T extends CtElement> spoon.reflect.path.impl.CtPathElement that match on CtNamedElement
class	CtTypedNameElement<P extends CtElement,T extends CtElement> spoon.reflect.path.impl.CtPathElement that match on CtNamedElement

Methods in spoon.reflect.path.impl with type parameters of type CtElement

Modifier and Type	Method and Description
<T extends CtElement> java.util.List<T>	CtPathImpl.evaluateOn(CtElement... startNode)

Methods in spoon.reflect.path.impl that return types with arguments of type CtElement

Modifier and Type	Method and Description
java.util.Collection<CtElement>	CtRolePathElement.getElements(java.util.Collection<CtElement> roots)
java.util.Collection<CtElement>	CtNamedPathElement.getElements(java.util.Collection<CtElement> roots)
java.util.Collection<CtElement>	CtNamedPathElement.scanElements(java.util.Collection<? extends CtElement> roots)

Methods in spoon.reflect.path.impl with parameters of type CtElement

Modifier and Type	Method and Description
<T extends CtElement> java.util.List<T>	CtPathImpl.evaluateOn(CtElement... startNode)
CtPath	CtPathImpl.relativePath(CtElement parent)

Method parameters in spoon.reflect.path.impl with type arguments of type CtElement

Modifier and Type	Method and Description
java.util.Collection<CtElement>	CtRolePathElement.getElements(java.util.Collection<CtElement> roots)
java.util.Collection<CtElement>	CtNamedPathElement.getElements(java.util.Collection<CtElement> roots)
java.util.Collection<CtElement>	CtNamedPathElement.scanElements(java.util.Collection<? extends CtElement> roots)

Uses of CtElement in spoon.reflect.reference

Subinterfaces of CtElement 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.

Methods in spoon.reflect.reference with type parameters of type CtElement

Modifier and Type	Method and Description
<E extends CtElement> E	CtTypeMemberWildcardImportReference.addAnnotation(CtAnnotation<? extends java.lang.annotation.Annotation> annotation)
<E extends CtElement> E	CtTypeMemberWildcardImportReference.setAnnotations(java.util.List<CtAnnotation<? extends java.lang.annotation.Annotation>> annotation)
<E extends CtElement> E	CtUnboundVariableReference.setAnnotations(java.util.List<CtAnnotation<? extends java.lang.annotation.Annotation>> annotation)
<E extends CtElement> E	CtReference.setComments(java.util.List<CtComment> comments) comments are not possible for references
<E extends CtElement> E	CtTypeMemberWildcardImportReference.setImplicit(boolean b)

Methods in spoon.reflect.reference that return CtElement

Modifier and Type	Method and Description
CtElement	CtReference.getDeclaration() Returns the declaration that corresponds to the referenced element only if the declaration is in the analyzed source files.

Uses of CtElement in spoon.reflect.visitor

Classes in spoon.reflect.visitor with type parameters of type CtElement

Modifier and Type	Interface and Description
interface	Filter<T extends CtElement> This interface defines a filter for program elements.

Fields in spoon.reflect.visitor with type parameters of type CtElement

Modifier and Type	Field and Description
protected java.util.Deque<CtElement>	CtDequeScanner.elementsDeque The stack of elements.
protected java.util.List<Processor<CtElement>>	DefaultJavaPrettyPrinter.preprocessors Handle imports of classes.
protected java.util.Deque<CtElement>	CtBiScannerDefault.stack

Methods in spoon.reflect.visitor with type parameters of type CtElement

Modifier and Type	Method and Description
static <E extends CtElement> java.util.List<E>	Query.getElements(CtElement rootElement, Filter<E> filter) Returns all the program elements that match the filter starting from the given rootElement.
static <E extends CtElement> java.util.List<E>	Query.getElements(Factory factory, Filter<E> filter) Within a given factory, returns all the program elements that match the filter.

Methods in spoon.reflect.visitor that return CtElement

Modifier and Type	Method and Description
CtElement	LexicalScope.getScopeElement()
CtElement	CtBFSIterator.next() Dereference the "iterator"
CtElement	CtIterator.next() Dereference the "iterator"

Methods in spoon.reflect.visitor that return types with arguments of type CtElement

Modifier and Type	Method and Description
java.util.List<Processor<CtElement>>	DefaultJavaPrettyPrinter.getPreprocessors()

Methods in spoon.reflect.visitor with parameters of type CtElement

Modifier and Type	Method and Description
PrinterHelper	PrinterHelper.adjustEndPosition(CtElement e)
PrinterHelper	PrinterHelper.adjustStartPosition(CtElement e) writes as many newlines as needed to align the line number again between the element position and the current line number
void	DefaultJavaPrettyPrinter.applyPreProcessors(CtElement el) Warning, this may change the state of the object
abstract void	CtAbstractBiScanner.biScan(CtElement element, CtElement other) This method is called to compare `element` and `other` when traversing two trees in parallel.
void	CtBiScannerDefault.biScan(CtElement element, CtElement other)
abstract void	CtAbstractBiScanner.biScan(CtRole role, CtElement element, CtElement other) This method is called to compare `element` and `other` according to the role when traversing two trees in parallel.
void	CtBiScannerDefault.biScan(CtRole role, CtElement element, CtElement other)
void	ImportScannerImpl.computeImports(CtElement element)
void	ImportScanner.computeImports(CtElement element) Computes import of a CtElement
protected void	EarlyTerminatingScanner.doScan(CtRole role, CtElement element, ScanningMode mode) This method is called ONLY when the listener decides that the current element and children should be visited.
protected void	DefaultJavaPrettyPrinter.enter(CtElement e) This method is called by DefaultJavaPrettyPrinter.scan(CtElement) when entering a scanned element.
protected void	ImportCleaner.ImportCleanerScanner.enter(CtElement e)
protected void	LexicalScopeScanner.enter(CtElement e)
void	ModelConsistencyChecker.enter(CtElement element) Enters an element.
protected void	CtDequeScanner.enter(CtElement e) Pushes the element.
protected void	CtScanner.enter(CtElement e) This method is upcalled by the scanner when entering a scanned element.
protected void	CtBiScannerDefault.enter(CtElement e)
protected void	DefaultJavaPrettyPrinter.exit(CtElement e) This method is called by DefaultJavaPrettyPrinter.scan(CtElement) when entering a scanned element.
protected void	ImportCleaner.ImportCleanerScanner.exit(CtElement e)
protected void	LexicalScopeScanner.exit(CtElement e)
protected void	ModelConsistencyChecker.exit(CtElement e) Exits an element.
protected void	CtDequeScanner.exit(CtElement e) Pops the element.
protected void	CtScanner.exit(CtElement e) This method is upcalled by the scanner when exiting a scanned element.
protected void	CtBiScannerDefault.exit(CtElement e)
java.util.List<CtComment>	ElementPrinterHelper.getComments(CtElement element, CommentOffset offset)
static <E extends CtElement> java.util.List<E>	Query.getElements(CtElement rootElement, Filter<E> filter) Returns all the program elements that match the filter starting from the given rootElement.
static <T extends CtReference> java.util.List<T>	Query.getReferences(CtElement rootElement, Filter<T> filter) Returns all the program element references that match the filter.
protected java.util.Set<java.lang.String>	ImportScannerImpl.lookForLocalVariables(CtElement parent)
void	PrinterHelper.mapLine(CtElement e, CtCompilationUnit unitExpected)
protected void	EarlyTerminatingScanner.onElement(CtRole role, CtElement element) Called for each scanned element.
java.lang.String	DefaultJavaPrettyPrinter.prettyprint(CtElement e)
java.lang.String	PrettyPrinter.prettyprint(CtElement ctElement) pretty-prints the element, call #toString() to get the result
java.lang.String	DefaultJavaPrettyPrinter.printElement(CtElement element) Prints an element.
java.lang.String	PrettyPrinter.printElement(CtElement element) Prints an element.
DefaultJavaPrettyPrinter	DefaultJavaPrettyPrinter.scan(CtElement e) The generic scan method for an element.
void	CtInheritanceScanner.scan(CtElement element) Generically scans a meta-model element.
void	CtBFSIterator.scan(CtElement element) prevent scanner from going down the tree, instead save with other CtElement children of the current node
void	EarlyTerminatingScanner.scan(CtElement element)
void	CtIterator.scan(CtElement element) prevent scanner from going down the tree, instead save with other CtElement children of the current node
void	ImportScannerImpl.scan(CtElement element)
void	AstParentConsistencyChecker.scan(CtElement element)
void	CtScanner.scan(CtElement element) Generically scans a meta-model element.
void	EarlyTerminatingScanner.scan(CtRole role, CtElement element)
void	CtScanner.scan(CtRole role, CtElement element) Generically scans a meta-model element.
void	CtInheritanceScanner.scanCtElement(CtElement e) Scans an abstract element.
void	ElementPrinterHelper.writeAnnotations(CtElement element) Writes the annotations for the given element.
void	ElementPrinterHelper.writeComment(CtElement element)
void	ElementPrinterHelper.writeComment(CtElement element, CommentOffset offset)

Method parameters in spoon.reflect.visitor with type arguments of type CtElement

Modifier and Type	Method and Description
protected void	CtBiScannerDefault.biScan(CtRole role, java.util.Collection<? extends CtElement> elements, java.util.Collection<? extends CtElement> others)
protected void	CtBiScannerDefault.biScan(CtRole role, java.util.Collection<? extends CtElement> elements, java.util.Collection<? extends CtElement> others)
void	CtInheritanceScanner.scan(java.util.Collection<? extends CtElement> elements) Generically scans a collection of meta-model elements.
void	CtScanner.scan(java.util.Collection<? extends CtElement> elements) Generically scans a collection of meta-model elements.
void	EarlyTerminatingScanner.scan(CtRole role, java.util.Collection<? extends CtElement> elements)
void	CtScanner.scan(CtRole role, java.util.Collection<? extends CtElement> elements) Generically scans a collection of meta-model elements.
void	EarlyTerminatingScanner.scan(CtRole role, java.util.Map<java.lang.String,? extends CtElement> elements)
void	CtScanner.scan(CtRole role, java.util.Map<java.lang.String,? extends CtElement> elements) Generically scans a Map of meta-model elements.
void	DefaultJavaPrettyPrinter.setPreprocessors(java.util.List<Processor<CtElement>> preprocessors)

Constructors in spoon.reflect.visitor with parameters of type CtElement

Constructor and Description
AccessibleVariablesFinder(CtElement expression)
CtBFSIterator(CtElement root) CtIterator constructor, prepares the iterator from the @root node
CtIterator(CtElement root) CtIterator constructor, prepares the iterator from the @root node

Uses of CtElement in spoon.reflect.visitor.chain

Methods in spoon.reflect.visitor.chain with type parameters of type CtElement

Modifier and Type	Method and Description
<R extends CtElement> CtQueryImpl	CtQueryImpl.filterChildren(Filter<R> filter)
<R extends CtElement> CtQuery	CtQueryable.filterChildren(Filter<R> filter)
<R extends CtElement> CtQuery	CtQuery.filterChildren(Filter<R> filter) Recursively scans all children elements of an input element.
<R extends CtElement> CtQueryImpl	CtQueryImpl.select(Filter<R> filter)
<R extends CtElement> CtQuery	CtQuery.select(Filter<R> filter) The matched element for which (filter.matches(element)==true) is sent to the next query step.

Methods in spoon.reflect.visitor.chain with parameters of type CtElement

Modifier and Type	Method and Description
default ScanningMode	CtScannerListener.enter(CtElement element) Called before the scanner enters an element
default ScanningMode	CtScannerListener.enter(CtRole role, CtElement element) Called before the scanner enters an element
default void	CtScannerListener.exit(CtElement element) This method is called after the element and all its children have been visited.
default void	CtScannerListener.exit(CtRole role, CtElement element) This method is called after the element and all its children have been visited.

Uses of CtElement in spoon.reflect.visitor.filter

Classes in spoon.reflect.visitor.filter with type parameters of type CtElement

Modifier and Type	Class and Description
class	AbstractFilter<T extends CtElement> Defines an abstract filter based on matching on the element types.
class	AnnotationFilter<E extends CtElement> This filter matches all the elements annotated with a given annotation type.
class	CompositeFilter<T extends CtElement> This class defines a composite filter, which can compose several filters together by using FilteringOperator.
class	RegexFilter<E extends CtElement> Filters elements with a regular expression on the element's code.
class	TypeFilter<T extends CtElement> This simple filter matches all the elements of a given type.

Fields in spoon.reflect.visitor.filter declared as CtElement

Modifier and Type	Field and Description
protected CtElement	VariableReferenceFunction.scope

Methods in spoon.reflect.visitor.filter that return types with arguments of type CtElement

Modifier and Type	Method and Description
java.lang.Class<CtElement>	RegexFilter.getType()

Methods in spoon.reflect.visitor.filter with parameters of type CtElement

Modifier and Type	Method and Description
void	SiblingsFunction.apply(CtElement input, CtConsumer<java.lang.Object> outputConsumer)
void	PotentialVariableDeclarationFunction.apply(CtElement input, CtConsumer<java.lang.Object> outputConsumer)
void	CtScannerFunction.apply(CtElement input, CtConsumer<java.lang.Object> outputConsumer)
void	FieldReferenceFunction.apply(CtElement fieldOrScope, CtConsumer<java.lang.Object> outputConsumer)
void	LocalVariableReferenceFunction.apply(CtElement scope, CtConsumer<java.lang.Object> outputConsumer)
void	ParentFunction.apply(CtElement input, CtConsumer<java.lang.Object> outputConsumer)
void	VariableReferenceFunction.apply(CtElement variableOrScope, CtConsumer<java.lang.Object> outputConsumer)
ScanningMode	SuperInheritanceHierarchyFunction.DistinctTypeListener.enter(CtElement element)
protected void	VariableScopeFunction.Visitor.enter(CtElement e)
protected void	VariableReferenceFunction.Visitor.enter(CtElement e)
void	SuperInheritanceHierarchyFunction.DistinctTypeListener.exit(CtElement element)
boolean	SameFilter.matches(CtElement element)

Constructors in spoon.reflect.visitor.filter with parameters of type CtElement

Constructor and Description
SameFilter(CtElement argument2)

Uses of CtElement in spoon.support

Methods in spoon.support with type parameters of type CtElement

Modifier and Type	Method and Description
<T extends CtElement> T	DefaultCoreFactory.clone(T object)

Methods in spoon.support that return CtElement

Modifier and Type	Method and Description
CtElement	DefaultCoreFactory.create(java.lang.Class<? extends CtElement> klass)

Methods in spoon.support that return types with arguments of type CtElement

Modifier and Type	Method and Description
FileGenerator<? extends CtElement>	StandardEnvironment.getDefaultFileGenerator()

Methods in spoon.support with parameters of type CtElement

Modifier and Type	Method and Description
void	RuntimeProcessingManager.process(CtElement element)
void	QueueProcessingManager.process(CtElement element)
void	RuntimeProcessingManager.process(CtElement element, Processor<?> processor) Recursively processes an element and its children with a given processor.
void	StandardEnvironment.report(Processor<?> processor, org.slf4j.event.Level level, CtElement element, java.lang.String message)

Method parameters in spoon.support with type arguments of type CtElement

Modifier and Type	Method and Description
CtElement	DefaultCoreFactory.create(java.lang.Class<? extends CtElement> klass)
void	RuntimeProcessingManager.process(java.util.Collection<? extends CtElement> elements)
void	QueueProcessingManager.process(java.util.Collection<? extends CtElement> elements)
void	RuntimeProcessingManager.process(java.util.Collection<? extends CtElement> elements, Processor<?> processor) Recursively processes elements and their children with a given processor.
void	StandardEnvironment.setDefaultFileGenerator(FileGenerator<? extends CtElement> defaultFileGenerator)

Uses of CtElement in spoon.support.comparator

Methods in spoon.support.comparator with parameters of type CtElement

Modifier and Type	Method and Description
int	SignatureComparator.compare(CtElement o1, CtElement o2)
int	CtLineElementComparator.compare(CtElement o1, CtElement o2) Returns 0 if o1 has the same position as o2, or both positions are invalid and o1.equals(o2).
int	QualifiedNameComparator.compare(CtElement o1, CtElement o2)
int	DeepRepresentationComparator.compare(CtElement o1, CtElement o2)

Uses of CtElement in spoon.support.compiler.jdt

Fields in spoon.support.compiler.jdt declared as CtElement

Modifier and Type	Field and Description
CtElement	ASTPair.element

Methods in spoon.support.compiler.jdt with parameters of type CtElement

Modifier and Type	Method and Description
void	ParentExiter.scanCtElement(CtElement e)
void	ParentExiter.setChild(CtElement child)

Method parameters in spoon.support.compiler.jdt with type arguments of type CtElement

Modifier and Type	Method and Description
void	JDTBasedSpoonCompiler.process(java.util.Collection<Processor<? extends CtElement>> processors)

Constructors in spoon.support.compiler.jdt with parameters of type CtElement

Constructor and Description
ASTPair(CtElement element, org.eclipse.jdt.internal.compiler.ast.ASTNode node)

Uses of CtElement in spoon.support.gui

Methods in spoon.support.gui with parameters of type CtElement

Modifier and Type	Method and Description
void	SpoonTreeBuilder.enter(CtElement element)
void	SpoonTreeBuilder.exit(CtElement element)
void	SpoonTreeBuilder.scan(CtRole role, CtElement element)

Constructors in spoon.support.gui with parameters of type CtElement

Constructor and Description
SpoonModelTree(CtElement rootElement)

Uses of CtElement in spoon.support.modelobs

Methods in spoon.support.modelobs with parameters of type CtElement

Modifier and Type	Method and Description
java.util.Set<CtRole>	ChangeCollector.getChanges(CtElement currentElement) Return the set of CtRoles for which children have changed from `currentElement` since this ChangeCollector was attached Warning: change in IMPLICIT are ignored
java.util.Set<CtRole>	ChangeCollector.getDirectChanges(CtElement currentElement)
protected void	SourceFragmentCreator.onChange(CtElement currentElement, CtRole role)
protected void	ChangeCollector.onChange(CtElement currentElement, CtRole role) Called whenever anything changes in the spoon model
void	ActionBasedChangeListenerImpl.onListAdd(CtElement currentElement, CtRole role, java.util.List field, CtElement newValue)
void	FineModelChangeListener.onListAdd(CtElement currentElement, CtRole role, java.util.List field, CtElement newValue) a newValue is appended to the list corresponding to the role in the AST node
void	EmptyModelChangeListener.onListAdd(CtElement currentElement, CtRole role, java.util.List field, CtElement newValue)
void	ActionBasedChangeListenerImpl.onListAdd(CtElement currentElement, CtRole role, java.util.List field, int index, CtElement newValue)
void	FineModelChangeListener.onListAdd(CtElement currentElement, CtRole role, java.util.List field, int index, CtElement newValue) a newValue is appended to the list corresponding to the role in the AST node
void	EmptyModelChangeListener.onListAdd(CtElement currentElement, CtRole role, java.util.List field, int index, CtElement newValue)
void	ActionBasedChangeListenerImpl.onListDelete(CtElement currentElement, CtRole role, java.util.List field, java.util.Collection<? extends CtElement> oldValue)
void	FineModelChangeListener.onListDelete(CtElement currentElement, CtRole role, java.util.List field, java.util.Collection<? extends CtElement> oldValue) an oldValue is deleted in the list corresponding to the role in the AST node
void	EmptyModelChangeListener.onListDelete(CtElement currentElement, CtRole role, java.util.List field, java.util.Collection<? extends CtElement> oldValue)
void	ActionBasedChangeListenerImpl.onListDelete(CtElement currentElement, CtRole role, java.util.List field, int index, CtElement oldValue)
void	FineModelChangeListener.onListDelete(CtElement currentElement, CtRole role, java.util.List field, int index, CtElement oldValue) an oldValue is deleted in the list corresponding to the role in the AST node
void	EmptyModelChangeListener.onListDelete(CtElement currentElement, CtRole role, java.util.List field, int index, CtElement oldValue)
void	ActionBasedChangeListenerImpl.onListDeleteAll(CtElement currentElement, CtRole role, java.util.List field, java.util.List oldValue)
void	FineModelChangeListener.onListDeleteAll(CtElement currentElement, CtRole role, java.util.List field, java.util.List oldValue) a list corresponding to the role in the AST node is emptied
void	EmptyModelChangeListener.onListDeleteAll(CtElement currentElement, CtRole role, java.util.List field, java.util.List oldValue)
<K,V> void	ActionBasedChangeListenerImpl.onMapAdd(CtElement currentElement, CtRole role, java.util.Map<K,V> field, K key, CtElement newValue)
<K,V> void	FineModelChangeListener.onMapAdd(CtElement currentElement, CtRole role, java.util.Map<K,V> field, K key, CtElement newValue) a newValue is appended to the map corresponding to the role in the AST node
<K,V> void	EmptyModelChangeListener.onMapAdd(CtElement currentElement, CtRole role, java.util.Map<K,V> field, K key, CtElement newValue)
<K,V> void	ActionBasedChangeListenerImpl.onMapDeleteAll(CtElement currentElement, CtRole role, java.util.Map<K,V> field, java.util.Map<K,V> oldValue)
<K,V> void	FineModelChangeListener.onMapDeleteAll(CtElement currentElement, CtRole role, java.util.Map<K,V> field, java.util.Map<K,V> oldValue) a map corresponding to the role in the AST node is emptied
<K,V> void	EmptyModelChangeListener.onMapDeleteAll(CtElement currentElement, CtRole role, java.util.Map<K,V> field, java.util.Map<K,V> oldValue)
void	ActionBasedChangeListenerImpl.onObjectDelete(CtElement currentElement, CtRole role, CtElement oldValue)
void	FineModelChangeListener.onObjectDelete(CtElement currentElement, CtRole role, CtElement oldValue) a field corresponding to the role is being set to null
void	EmptyModelChangeListener.onObjectDelete(CtElement currentElement, CtRole role, CtElement oldValue)
void	ActionBasedChangeListenerImpl.onObjectUpdate(CtElement currentElement, CtRole role, CtElement newValue, CtElement oldValue)
void	FineModelChangeListener.onObjectUpdate(CtElement currentElement, CtRole role, CtElement newValue, CtElement oldValue) a field corresponding to the role is being set in the AST node
void	EmptyModelChangeListener.onObjectUpdate(CtElement currentElement, CtRole role, CtElement newValue, CtElement oldValue)
void	ActionBasedChangeListenerImpl.onObjectUpdate(CtElement currentElement, CtRole role, java.lang.Object newValue, java.lang.Object oldValue)
void	FineModelChangeListener.onObjectUpdate(CtElement currentElement, CtRole role, java.lang.Object newValue, java.lang.Object oldValue) a field corresponding to the role is being set in the AST node
void	EmptyModelChangeListener.onObjectUpdate(CtElement currentElement, CtRole role, java.lang.Object newValue, java.lang.Object oldValue)
void	ActionBasedChangeListenerImpl.onSetAdd(CtElement currentElement, CtRole role, java.util.Set field, CtElement newValue)
void	FineModelChangeListener.onSetAdd(CtElement currentElement, CtRole role, java.util.Set field, CtElement newValue) a newValue is appended to the set corresponding to the role in the AST node
void	EmptyModelChangeListener.onSetAdd(CtElement currentElement, CtRole role, java.util.Set field, CtElement newValue)
<T extends java.lang.Enum> void	ActionBasedChangeListenerImpl.onSetAdd(CtElement currentElement, CtRole role, java.util.Set field, T newValue)
<T extends java.lang.Enum> void	FineModelChangeListener.onSetAdd(CtElement currentElement, CtRole role, java.util.Set field, T newValue) a newValue is appended to the set corresponding to the role in the AST node
<T extends java.lang.Enum> void	EmptyModelChangeListener.onSetAdd(CtElement currentElement, CtRole role, java.util.Set field, T newValue)
void	ActionBasedChangeListenerImpl.onSetDelete(CtElement currentElement, CtRole role, java.util.Set field, java.util.Collection<ModifierKind> oldValue)
void	FineModelChangeListener.onSetDelete(CtElement currentElement, CtRole role, java.util.Set field, java.util.Collection<ModifierKind> oldValue) an oldValue is deleted in the set corresponding to the role in the AST node
void	EmptyModelChangeListener.onSetDelete(CtElement currentElement, CtRole role, java.util.Set field, java.util.Collection<ModifierKind> oldValue)
void	ActionBasedChangeListenerImpl.onSetDelete(CtElement currentElement, CtRole role, java.util.Set field, CtElement oldValue)
void	FineModelChangeListener.onSetDelete(CtElement currentElement, CtRole role, java.util.Set field, CtElement oldValue) an oldValue is deleted in the set corresponding to the role in the AST node
void	EmptyModelChangeListener.onSetDelete(CtElement currentElement, CtRole role, java.util.Set field, CtElement oldValue)
void	ActionBasedChangeListenerImpl.onSetDelete(CtElement currentElement, CtRole role, java.util.Set field, ModifierKind oldValue)
void	FineModelChangeListener.onSetDelete(CtElement currentElement, CtRole role, java.util.Set field, ModifierKind oldValue) an oldValue is deleted in the set corresponding to the role in the AST node
void	EmptyModelChangeListener.onSetDelete(CtElement currentElement, CtRole role, java.util.Set field, ModifierKind oldValue)
void	ActionBasedChangeListenerImpl.onSetDeleteAll(CtElement currentElement, CtRole role, java.util.Set field, java.util.Set oldValue)
void	FineModelChangeListener.onSetDeleteAll(CtElement currentElement, CtRole role, java.util.Set field, java.util.Set oldValue) a set corresponding to the role in the AST node is emptied
void	EmptyModelChangeListener.onSetDeleteAll(CtElement currentElement, CtRole role, java.util.Set field, java.util.Set oldValue)

Method parameters in spoon.support.modelobs with type arguments of type CtElement

Modifier and Type	Method and Description
void	ActionBasedChangeListenerImpl.onListDelete(CtElement currentElement, CtRole role, java.util.List field, java.util.Collection<? extends CtElement> oldValue)
void	FineModelChangeListener.onListDelete(CtElement currentElement, CtRole role, java.util.List field, java.util.Collection<? extends CtElement> oldValue) an oldValue is deleted in the list corresponding to the role in the AST node
void	EmptyModelChangeListener.onListDelete(CtElement currentElement, CtRole role, java.util.List field, java.util.Collection<? extends CtElement> oldValue)

Uses of CtElement in spoon.support.modelobs.context

Methods in spoon.support.modelobs.context that return CtElement

Modifier and Type	Method and Description
CtElement	Context.getElementWhereChangeHappens() the changed parent

Constructors in spoon.support.modelobs.context with parameters of type CtElement

Constructor and Description
CollectionContext(CtElement element, CtRole role, T copyOfTheCollection)
Context(CtElement element, CtRole changedProperty)
ListContext(CtElement element, CtRole role, java.util.List<?> original)
ListContext(CtElement element, CtRole role, java.util.List<?> original, int position)
MapContext(CtElement element, CtRole role, java.util.Map<K,V> map)
MapContext(CtElement element, CtRole role, java.util.Map<K,V> map, K key)
ObjectContext(CtElement ctElement, CtRole role)
SetContext(CtElement element, CtRole role, java.util.Set<?> original)

Uses of CtElement in spoon.support.reflect

Constructors in spoon.support.reflect with parameters of type CtElement

Constructor and Description
CtModifierHandler(CtElement element)

Uses of CtElement in spoon.support.reflect.code

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

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

Methods in spoon.support.reflect.code with type parameters of type CtElement

Modifier and Type	Method and Description
<E extends CtElement> E	CtTypeAccessImpl.setImplicit(boolean implicit)
<E extends CtElement> E	CtStatementListImpl.setPosition(SourcePosition position)

Uses of CtElement in spoon.support.reflect.cu

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

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

Uses of CtElement in spoon.support.reflect.declaration

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

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

Fields in spoon.support.reflect.declaration declared as CtElement

Modifier and Type	Field and Description
protected CtElement	CtElementImpl.parent

Methods in spoon.support.reflect.declaration with type parameters of type CtElement

Modifier and Type	Method and Description
<E extends CtElement> E	CtElementImpl.addAnnotation(CtAnnotation<? extends java.lang.annotation.Annotation> annotation)
<E extends CtElement> E	CtElementImpl.addComment(CtComment comment)
<P extends CtElement> CtQuery	CtElementImpl.filterChildren(Filter<P> predicate)
<E extends CtElement> java.util.List<E>	CtElementImpl.getAnnotatedChildren(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
<E extends CtElement> java.util.List<E>	CtElementImpl.getElements(Filter<E> filter)
<P extends CtElement> P	CtElementImpl.getParent(java.lang.Class<P> parentType)
<E extends CtElement> E	CtElementImpl.getParent(Filter<E> filter)
<E extends CtElement> E	CtElementImpl.putMetadata(java.lang.String key, java.lang.Object val)
<E extends CtElement> E	CtElementImpl.removeComment(CtComment comment)
<E extends CtElement> void	CtElementImpl.replace(java.util.Collection<E> elements)
<E extends CtElement> E	CtElementImpl.setAllMetadata(java.util.Map<java.lang.String,java.lang.Object> metadata)
<E extends CtElement> E	CtElementImpl.setAnnotations(java.util.List<CtAnnotation<? extends java.lang.annotation.Annotation>> annotations)
<E extends CtElement> E	CtElementImpl.setComments(java.util.List<CtComment> comments)
<E extends CtElement> E	CtElementImpl.setDocComment(java.lang.String docComment)
<E extends CtElement> E	CtElementImpl.setImplicit(boolean implicit)
<E extends CtElement> E	CtCompilationUnitImpl.setParent(E parent)
<E extends CtElement> E	CtElementImpl.setParent(E parent)
<T extends CtElement> T	CtModuleImpl.setParent(T parent)
<E extends CtElement> E	CtCompilationUnitImpl.setPosition(SourcePosition position)
<E extends CtElement> E	CtElementImpl.setPosition(SourcePosition position)
<E extends CtElement> E	CtElementImpl.setPositions(SourcePosition position)
<E extends CtElement,T> E	CtElementImpl.setValueByRole(CtRole role, T value)

Methods in spoon.support.reflect.declaration that return CtElement

Modifier and Type	Method and Description
CtElement	CtElementImpl.clone()
CtElement	CtAnnotationImpl.getAnnotatedElement()
CtElement	CtCompilationUnitImpl.getParent()
CtElement	CtModuleImpl.getParent()
CtElement	CtElementImpl.getParent()

Methods in spoon.support.reflect.declaration that return types with arguments of type CtElement

Modifier and Type	Method and Description
java.lang.Iterable<CtElement>	CtElementImpl.asIterable()
java.util.Iterator<CtElement>	CtElementImpl.descendantIterator()
java.util.List<CtElement>	CtElementImpl.getDirectChildren()

Methods in spoon.support.reflect.declaration with parameters of type CtElement

Modifier and Type	Method and Description
boolean	CtElementImpl.hasParent(CtElement candidate)
void	CtElementImpl.replace(CtElement element)

Uses of CtElement in spoon.support.reflect.eval

Methods in spoon.support.reflect.eval with type parameters of type CtElement

Modifier and Type	Method and Description
<R extends CtElement> R	VisitorPartialEvaluator.evaluate(R element)

Methods in spoon.support.reflect.eval with parameters of type CtElement

Modifier and Type	Method and Description
static java.lang.Object	EvalHelper.convertElementToRuntimeObject(CtElement value) Evaluates and converts CtExpression to their equivalent runtime objects eg "CtLiteral(3) + CtLiteral(4)" -> 7
protected void	VisitorPartialEvaluator.exit(CtElement e)
protected void	InlinePartialEvaluator.exit(CtElement e)

Uses of CtElement in spoon.support.reflect.reference

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

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

Methods in spoon.support.reflect.reference with type parameters of type CtElement

Modifier and Type	Method and Description
<E extends CtElement> E	CtTypeMemberWildcardImportReferenceImpl.addAnnotation(CtAnnotation<? extends java.lang.annotation.Annotation> annotation)
<E extends CtElement> E	CtTypeMemberWildcardImportReferenceImpl.setAnnotations(java.util.List<CtAnnotation<? extends java.lang.annotation.Annotation>> annotations)
<E extends CtElement> E	CtUnboundVariableReferenceImpl.setAnnotations(java.util.List<CtAnnotation<? extends java.lang.annotation.Annotation>> annotations)
<E extends CtElement> E	CtReferenceImpl.setComments(java.util.List<CtComment> comments)
<E extends CtElement> E	CtTypeMemberWildcardImportReferenceImpl.setImplicit(boolean implicit)

Uses of CtElement in spoon.support.sniper

Methods in spoon.support.sniper with parameters of type CtElement

Modifier and Type	Method and Description
static boolean	SniperJavaPrettyPrinter.hasImplicitAncestor(CtElement el) Warning, not in the API, public for testing purposes
java.lang.String	SniperJavaPrettyPrinter.printElement(CtElement element) The sniper mode only works from JavaOutputProcessor
java.lang.String	SniperJavaPrettyPrinter.printElementSniper(CtElement element) Warning: debug and test method only, not part of the public API
SniperJavaPrettyPrinter	SniperJavaPrettyPrinter.scan(CtElement element) Called whenever DefaultJavaPrettyPrinter scans/prints an element Warning: DO not call on a cloned element.

Uses of CtElement in spoon.support.sniper.internal

Fields in spoon.support.sniper.internal declared as CtElement

Modifier and Type	Field and Description
protected CtElement	ElementPrinterEvent.element

Methods in spoon.support.sniper.internal with parameters of type CtElement

Modifier and Type	Method and Description
static ElementSourceFragment	ElementSourceFragment.createSourceFragmentsFrom(CtElement element) Builds a tree of source fragments for `element` and all its children, based on the source positions of each element

Constructors in spoon.support.sniper.internal with parameters of type CtElement

Constructor and Description
ChangeResolver(ChangeCollector changeCollector, CtElement element)
ElementPrinterEvent(CtRole role, CtElement element)
SourceFragmentContextList(MutableTokenWriter mutableTokenWriter, CtElement element, java.util.List<SourceFragment> fragments, ChangeResolver changeResolver)

Uses of CtElement in spoon.support.util

Classes in spoon.support.util with type parameters of type CtElement

Modifier and Type	Class and Description
class	ModelList<T extends CtElement> The implementation of the List, which is used by Spoon model objects.
class	ModelSet<T extends CtElement> The implementation of the Set, which is used by Spoon model objects.
class	QualifiedNameBasedSortedSet<E extends CtElement> The set properties of this set are based on the qualified name of the element inserted.

Methods in spoon.support.util that return CtElement

Modifier and Type	Method and Description
protected abstract CtElement	ModelList.getOwner()
protected abstract CtElement	ModelSet.getOwner()

Constructor parameters in spoon.support.util with type arguments of type CtElement

Constructor and Description
ModelSet(java.util.Comparator<? super CtElement> comparator)

Uses of CtElement in spoon.support.visitor

Methods in spoon.support.visitor with parameters of type CtElement

Modifier and Type	Method and Description
void	ProcessingVisitor.scan(CtElement e) Applies the processing to the given element.
void	HashcodeVisitor.scan(CtElement element)

Uses of CtElement in spoon.support.visitor.clone

Methods in spoon.support.visitor.clone with type parameters of type CtElement

Modifier and Type	Method and Description
static <T extends CtElement> T	CloneBuilder.build(CloneBuilder builder, CtElement element, CtElement other)
<T extends CtElement> T	CloneVisitor.getClone()

Methods in spoon.support.visitor.clone with parameters of type CtElement

Modifier and Type	Method and Description
static <T extends CtElement> T	CloneBuilder.build(CloneBuilder builder, CtElement element, CtElement other)
void	CloneBuilder.copy(CtElement element, CtElement other)
void	CloneBuilder.scanCtElement(CtElement e) Scans an abstract element.
void	CloneBuilder.setOther(CtElement other)

Uses of CtElement in spoon.support.visitor.equals

Fields in spoon.support.visitor.equals declared as CtElement

Modifier and Type	Field and Description
protected CtElement	EqualsChecker.other

Methods in spoon.support.visitor.equals with type parameters of type CtElement

Modifier and Type	Method and Description
protected <T extends CtElement> void	CloneHelper.addClone(java.util.Collection<T> targetCollection, T element) clones an element and adds it's clone as value into targetCollection
protected <T extends CtElement> void	CloneHelper.addClone(java.util.Map<java.lang.String,T> targetMap, java.lang.String key, T value) clones a value and adds it's clone as value into targetMap under key
<T extends CtElement> java.util.Collection<T>	CloneHelper.clone(java.util.Collection<T> elements)
<T extends CtElement> java.util.List<T>	CloneHelper.clone(java.util.List<T> elements)
<T extends CtElement> java.util.Map<java.lang.String,T>	CloneHelper.clone(java.util.Map<java.lang.String,T> elements)
<T extends CtElement> java.util.Set<T>	CloneHelper.clone(java.util.Set<T> elements) clones a Set of elements
<T extends CtElement> T	CloneHelper.clone(T element)

Methods in spoon.support.visitor.equals with parameters of type CtElement

Modifier and Type	Method and Description
void	EqualsVisitor.biScan(CtElement element, CtElement other)
void	EqualsVisitor.biScan(CtRole role, CtElement element, CtElement other)
boolean	EqualsVisitor.checkEquals(CtElement element, CtElement other)
protected void	EqualsVisitor.enter(CtElement e)
static boolean	EqualsVisitor.equals(CtElement element, CtElement other)
void	EqualsChecker.setOther(CtElement other)
void	CloneHelper.tailor(CtElement topLevelElement, CtElement topLevelClone) Is called by CloneVisitor at the end of the cloning for each element.

Method parameters in spoon.support.visitor.equals with type arguments of type CtElement

Modifier and Type	Method and Description
protected void	EqualsVisitor.biScan(CtRole role, java.util.Collection<? extends CtElement> elements, java.util.Collection<? extends CtElement> others)
protected void	EqualsVisitor.biScan(CtRole role, java.util.Collection<? extends CtElement> elements, java.util.Collection<? extends CtElement> others)

Uses of CtElement in spoon.support.visitor.replace

Classes in spoon.support.visitor.replace with type parameters of type CtElement

Modifier and Type	Interface and Description
interface	ReplaceListener<T extends CtElement> Interface for the AST node replacement infrastructure.

Methods in spoon.support.visitor.replace with type parameters of type CtElement

Modifier and Type	Method and Description
static <E extends CtElement> void	ReplacementVisitor.replace(CtElement original, java.util.Collection<E> replaces)

Methods in spoon.support.visitor.replace with parameters of type CtElement

Modifier and Type	Method and Description
static <E extends CtElement> void	ReplacementVisitor.replace(CtElement original, java.util.Collection<E> replaces)
static void	ReplacementVisitor.replace(CtElement original, CtElement replace)

Uses of CtElement in spoon.template

Classes in spoon.template with type parameters of type CtElement

Modifier and Type	Class and Description
class	AbstractTemplate<T extends CtElement> handles the well-formedness and helper methods of templates
interface	Template<T extends CtElement> A template code is simply a piece of code that uses a TemplateParameter's instance.

Methods in spoon.template with type parameters of type CtElement

Modifier and Type	Method and Description
<T extends CtElement> java.util.List<T>	TemplateMatcher.find(CtElement targetRoot) Finds all target program sub-trees that correspond to a template.
static <E extends CtElement> E	Substitution.substitute(CtType<?> targetType, Template<?> template, E code) Substitutes all the template parameters in a random piece of code.

Methods in spoon.template with parameters of type CtElement

Modifier and Type	Method and Description
<T extends CtElement> java.util.List<T>	TemplateMatcher.find(CtElement targetRoot) Finds all target program sub-trees that correspond to a template.
void	TemplateMatcher.forEachMatch(CtElement rootElement, CtConsumer<Match> consumer) Finds all target program sub-trees that correspond to a template and calls consumer.accept(matchingElement, )
boolean	TemplateMatcher.matches(CtElement element)
static void	Substitution.redirectTypeReferences(CtElement element, CtTypeReference<?> source, CtTypeReference<?> target) A helper method that recursively redirects all the type references from a source type to a target type in the given element.

Constructors in spoon.template with parameters of type CtElement

Constructor and Description
TemplateMatcher(CtElement templateRoot) Constructs a matcher for a given template.
TemplateMatcher(CtElement templateRoot, CtClass<?> templateType) Constructs a matcher for a given template.

Uses of CtElement in spoon.testing

Methods in spoon.testing with parameters of type CtElement

Modifier and Type	Method and Description
static AbstractCtElementAssert<?>	Assert.assertThat(CtElement actual) Create a new instance of CtElementAssert.
T	AbstractCtElementAssert.isEqualTo(CtElement expected) Verifies that the actual value is equal to the given one.

Constructors in spoon.testing with parameters of type CtElement

Constructor and Description
AbstractCtElementAssert(CtElement actual, java.lang.Class<?> selfType)
CtElementAssert(CtElement actual)

Uses of CtElement in spoon.testing.utils

Methods in spoon.testing.utils with type parameters of type CtElement

Modifier and Type	Method and Description
static <A extends CtElement,E extends CtElement> A	Check.assertIsSame(A actual, E expected)
static <A extends CtElement,E extends CtElement> A	Check.assertIsSame(A actual, E expected)

Methods in spoon.testing.utils with parameters of type CtElement

Modifier and Type	Method and Description
static void	Check.assertCtElementEquals(CtElement ct1, CtElement ct2) if ct1 is not equals to ct2, tells the exact difference