Package | Description |
---|---|
spoon.refactoring | |
spoon.reflect.code |
This package contains the meta-model part that models the executable code (methods and constructors' bodies, field initializers).
|
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.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.compiler | |
spoon.support.compiler.jdt | |
spoon.support.reflect.code | |
spoon.support.reflect.declaration | |
spoon.support.reflect.eval | |
spoon.support.template |
This package defines the substitution and matching engines for Java templates.
|
spoon.support.visitor.clone | |
spoon.support.visitor.replace | |
spoon.template |
This package defines a framework for well-typed pure-Java templates.
|
Modifier and Type | Method and Description |
---|---|
protected boolean |
CtParameterRemoveRefactoring.canRemoveExpression(CtExpression<?> toBeRemovedExpression)
Detects whether `toBeRemovedExpression` can be safely removed during the refactoring
|
protected void |
CtParameterRemoveRefactoring.createExpressionCannotBeRemovedIssue(CtInvocation<?> invocation,
CtExpression<?> toBeRemovedExpression)
Override this method to get access to details about this refactoring issue.
|
Modifier and Type | Interface and Description |
---|---|
interface |
CtArrayAccess<T,E extends CtExpression<?>>
This code element defines a one-dimensional array access.
|
interface |
CtExecutableReferenceExpression<T,E extends CtExpression<?>>
This abstract code element defines an expression which represents an executable reference.
|
interface |
CtTargetedExpression<T,E extends CtExpression<?>>
This abstract code element defines an expression which contains a target
expression.
|
Modifier and Type | Interface and Description |
---|---|
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 |
CtAssignment<T,A extends T>
This code element defines an assignment.
|
interface |
CtBinaryOperator<T>
This interface defines a binary operator.
|
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 |
CtConditional<T>
This code element defines conditional expressions using the ? (ternary expressions).
|
interface |
CtConstructorCall<T>
This code element represents a constructor call.
|
interface |
CtExecutableReferenceExpression<T,E extends CtExpression<?>>
This abstract code element defines an expression which represents an executable reference.
|
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 |
CtInvocation<T>
This code element defines a concrete invocation.
|
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 |
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 |
CtSuperAccess<T>
This code element defines an access to super.
|
interface |
CtSwitchExpression<T,S>
This code element defines a switch expression.
|
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 |
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.
|
Modifier and Type | Method and Description |
---|---|
<C extends CtExpression<T>> |
CtExpression.addTypeCast(CtTypeReference<?> type)
Adds a type cast.
|
<E extends CtExpression<T>> |
CtCodeSnippetExpression.compile()
Compiles this expression snippet to produce the corresponding AST expression.
|
<C extends CtExpression<T>> |
CtExpression.setTypeCasts(java.util.List<CtTypeReference<?>> types)
Sets the type casts.
|
Modifier and Type | Method and Description |
---|---|
CtExpression<T> |
CtExpression.clone() |
CtExpression<java.lang.Boolean> |
CtAssert.getAssertExpression()
Gets the assert expression.
|
CtExpression<T> |
CtAssignment.getAssigned()
Returns the assigned expression on the left-hand side (where the value is stored,
e.g.
|
CtExpression<T> |
CtLocalVariable.getAssignment()
Useful proxy to
CtVariable.getDefaultExpression() . |
CtExpression<A> |
CtRHSReceiver.getAssignment()
Returns the right-hand side of the "=" operator.
|
CtExpression<S> |
CtCase.getCaseExpression()
Gets the case expression.
|
CtExpression<java.lang.Boolean> |
CtIf.getCondition()
Gets the boolean expression that represents the
if 's
condition. |
CtExpression<java.lang.Boolean> |
CtConditional.getCondition()
Gets the condition expression.
|
CtExpression<T> |
CtConditional.getElseExpression()
Gets the "false" expression.
|
CtExpression<T> |
CtAssert.getExpression()
Gets the expression of the assertion if defined.
|
CtExpression<java.lang.Boolean> |
CtFor.getExpression()
Gets the end-loop test expression.
|
CtExpression<?> |
CtSynchronized.getExpression()
Gets the expression that defines the monitored object if any.
|
CtExpression<?> |
CtYieldStatement.getExpression()
Gets the expression of the yield statement.
|
CtExpression<?> |
CtForEach.getExpression()
Gets the iterated expression (an iterable of an array).
|
CtExpression<T> |
CtLambda.getExpression()
Gets the expression in the body.
|
CtExpression<java.lang.Integer> |
CtArrayAccess.getIndexExpression()
Returns the expression that defines the index.
|
CtExpression<?> |
CtBinaryOperator.getLeftHandOperand()
Returns the left-hand operand.
|
CtExpression<java.lang.Boolean> |
CtDo.getLoopingExpression()
Returns the looping test as a boolean expression.
|
CtExpression<java.lang.Boolean> |
CtWhile.getLoopingExpression()
Gets the looping boolean test expression.
|
CtExpression<T> |
CtUnaryOperator.getOperand()
Gets the expression to which the operator is applied.
|
CtExpression<R> |
CtReturn.getReturnedExpression()
Gets the returned expression.
|
CtExpression<?> |
CtBinaryOperator.getRightHandOperand()
Returns the right-hand operand.
|
CtExpression<S> |
CtAbstractSwitch.getSelector()
Gets the selector.
|
CtExpression<T> |
CtConditional.getThenExpression()
Gets the "true" expression.
|
CtExpression<? extends java.lang.Throwable> |
CtThrow.getThrownExpression()
Returns the thrown expression (must be a throwable).
|
Modifier and Type | Method and Description |
---|---|
java.util.List<CtExpression<?>> |
CtAbstractInvocation.getArguments()
The arguments of the invocation.
|
java.util.List<CtExpression<S>> |
CtCase.getCaseExpressions()
Gets the case expressions.
|
java.util.List<CtExpression<java.lang.Integer>> |
CtNewArray.getDimensionExpressions()
Gets the expressions that define the array's dimensions.
|
java.util.List<CtExpression<?>> |
CtNewArray.getElements()
Gets the initialization expressions.
|
Modifier and Type | Method and Description |
---|---|
<C extends CtAbstractInvocation<T>> |
CtAbstractInvocation.addArgument(CtExpression<?> argument)
Adds an argument expression to the invocation.
|
<T extends CtCase<S>> |
CtCase.addCaseExpression(CtExpression<S> caseExpression)
Adds case expression.
|
<C extends CtNewArray<T>> |
CtNewArray.addDimensionExpression(CtExpression<java.lang.Integer> dimension)
Adds a dimension expression.
|
<C extends CtNewArray<T>> |
CtNewArray.addElement(CtExpression<?> expression)
Adds an element.
|
void |
CtAbstractInvocation.removeArgument(CtExpression<?> argument)
Removes an argument expression from the invocation.
|
boolean |
CtNewArray.removeDimensionExpression(CtExpression<java.lang.Integer> dimension)
Removes a dimension expression.
|
boolean |
CtNewArray.removeElement(CtExpression<?> expression)
Removes an element.
|
<A extends CtAssert<T>> |
CtAssert.setAssertExpression(CtExpression<java.lang.Boolean> asserted)
Sets the assert expression.
|
<C extends CtAssignment<T,A>> |
CtAssignment.setAssigned(CtExpression<T> assigned)
Sets the assigned expression (left hand side - LHS).
|
<T extends CtRHSReceiver<A>> |
CtRHSReceiver.setAssignment(CtExpression<A> assignment)
Sets the right-hand side expression (RHS) of the "=" operator.
|
<U extends CtRHSReceiver<T>> |
CtLocalVariable.setAssignment(CtExpression<T> assignment) |
<T extends CtCase<S>> |
CtCase.setCaseExpression(CtExpression<S> caseExpression)
Sets the case expression.
|
<C extends CtConditional<T>> |
CtConditional.setCondition(CtExpression<java.lang.Boolean> condition)
Sets the condition expression.
|
<T extends CtIf> |
CtIf.setCondition(CtExpression<java.lang.Boolean> expression)
Sets the boolean expression that represents the
if 's
condition. |
<C extends CtVariable<T>> |
CtCatchVariable.setDefaultExpression(CtExpression<T> assignedExpression) |
<C extends CtConditional<T>> |
CtConditional.setElseExpression(CtExpression<T> elseExpression)
Sets the "false" expression.
|
<T extends CtForEach> |
CtForEach.setExpression(CtExpression<?> expression)
Sets the iterated expression (an iterable of an array).
|
<T extends CtSynchronized> |
CtSynchronized.setExpression(CtExpression<?> expression)
Sets the expression that defines the monitored.
|
<T extends CtYieldStatement> |
CtYieldStatement.setExpression(CtExpression<?> expression)
Gets the expression of the yield statement.
|
<T extends CtFor> |
CtFor.setExpression(CtExpression<java.lang.Boolean> expression)
Sets the end-loop test expression.
|
<A extends CtAssert<T>> |
CtAssert.setExpression(CtExpression<T> expression)
Sets the expression of the assertion.
|
<C extends CtLambda<T>> |
CtLambda.setExpression(CtExpression<T> expression)
Sets the expression in the body of the lambda.
|
<C extends CtArrayAccess<T,E>> |
CtArrayAccess.setIndexExpression(CtExpression<java.lang.Integer> expression)
Sets the expression that defines the index.
|
<C extends CtBinaryOperator<T>> |
CtBinaryOperator.setLeftHandOperand(CtExpression<?> expression)
Sets the left-hand operand.
|
<T extends CtDo> |
CtDo.setLoopingExpression(CtExpression<java.lang.Boolean> expression)
Sets the looping test as a boolean expression.
|
<T extends CtWhile> |
CtWhile.setLoopingExpression(CtExpression<java.lang.Boolean> expression)
Sets the looping boolean test expression.
|
<C extends CtUnaryOperator> |
CtUnaryOperator.setOperand(CtExpression<T> expression)
Sets the expression to which the operator is applied.
|
<T extends CtReturn<R>> |
CtReturn.setReturnedExpression(CtExpression<R> returnedExpression)
Sets the returned expression.
|
<C extends CtBinaryOperator<T>> |
CtBinaryOperator.setRightHandOperand(CtExpression<?> expression)
Sets the right-hand operand.
|
<T extends CtAbstractSwitch<S>> |
CtAbstractSwitch.setSelector(CtExpression<S> selector)
Sets the selector.
|
<C extends CtConditional<T>> |
CtConditional.setThenExpression(CtExpression<T> thenExpression)
Sets the "true" expression.
|
<T extends CtThrow> |
CtThrow.setThrownExpression(CtExpression<? extends java.lang.Throwable> thrownExpression)
Sets the thrown expression (must be a throwable).
|
Modifier and Type | Method and Description |
---|---|
<C extends CtAbstractInvocation<T>> |
CtAbstractInvocation.setArguments(java.util.List<CtExpression<?>> arguments)
Sets the invocation's arguments.
|
<T extends CtCase<S>> |
CtCase.setCaseExpressions(java.util.List<CtExpression<S>> caseExpressions)
Sets the case expressions.
|
<C extends CtNewArray<T>> |
CtNewArray.setDimensionExpressions(java.util.List<CtExpression<java.lang.Integer>> dimensions)
Sets the expressions that define the array's dimensions.
|
<C extends CtNewArray<T>> |
CtNewArray.setElements(java.util.List<CtExpression<?>> expression)
Sets the initialization expressions.
|
Modifier and Type | Interface and Description |
---|---|
interface |
CtAnnotation<A extends java.lang.annotation.Annotation>
This element represents an annotation on an element.
|
Modifier and Type | Method and Description |
---|---|
<T extends CtExpression> |
CtAnnotation.getValue(java.lang.String key)
Gets a value, as a CtExpression, for a given key without any conversion.
|
<T extends CtExpression> |
CtAnnotation.getWrappedValue(java.lang.String key)
Gets a value for a given key and try to fix its type based on the
annotation type.
|
<C extends CtExpression<A>> |
CtAnnotation.setTypeCasts(java.util.List<CtTypeReference<?>> types) |
Modifier and Type | Method and Description |
---|---|
CtExpression<T> |
CtField.getAssignment()
Useful proxy to
CtVariable.getDefaultExpression() . |
CtExpression<T> |
CtAnnotationMethod.getDefaultExpression()
Gets the default expression assigned to the annotation method.
|
CtExpression<T> |
CtVariable.getDefaultExpression()
Gets the initialization expression assigned to the variable (also known
as the initializer), when declared.
|
Modifier and Type | Method and Description |
---|---|
java.util.Map<java.lang.String,CtExpression> |
CtAnnotation.getAllValues()
Get all values of
CtAnnotation.getValues() , plus the default ones defined in the annotation type. |
java.util.Map<java.lang.String,CtExpression> |
CtAnnotation.getValues()
Returns this annotation's elements and their values.
|
Modifier and Type | Method and Description |
---|---|
<U extends CtRHSReceiver<T>> |
CtEnumValue.setAssignment(CtExpression<T> assignment) |
<U extends CtRHSReceiver<T>> |
CtField.setAssignment(CtExpression<T> assignment) |
<C extends CtAnnotationMethod<T>> |
CtAnnotationMethod.setDefaultExpression(CtExpression<T> assignedExpression)
Sets the default expression assigned to the annotation method.
|
<C extends CtVariable<T>> |
CtParameter.setDefaultExpression(CtExpression<T> assignedExpression) |
<C extends CtVariable<T>> |
CtVariable.setDefaultExpression(CtExpression<T> assignedExpression)
Sets the initialization expression assigned to the variable, when
declared.
|
Modifier and Type | Method and Description |
---|---|
<T extends CtAnnotation<A>> |
CtAnnotation.addValue(java.lang.String elementName,
CtNewArray<? extends CtExpression> value)
Adds a new key-array pair for this annotation.
|
<T extends CtAnnotation<A>> |
CtAnnotation.setValues(java.util.Map<java.lang.String,CtExpression> values)
Set's this annotation's element names and their values.
|
Modifier and Type | Method and Description |
---|---|
<T,E extends CtExpression<?>> |
Factory.createExecutableReferenceExpression() |
<T,E extends CtExpression<?>> |
CoreFactory.createExecutableReferenceExpression()
Creates a new executable reference expression.
|
<T,E extends CtExpression<?>> |
FactoryImpl.createExecutableReferenceExpression() |
Modifier and Type | Method and Description |
---|---|
java.util.List<CtExpression<?>> |
Factory.createVariableReads(java.util.List<? extends CtVariable<?>> variables) |
java.util.List<CtExpression<?>> |
CodeFactory.createVariableReads(java.util.List<? extends CtVariable<?>> variables)
Creates a list of variable accesses for read.
|
java.util.List<CtExpression<?>> |
FactoryImpl.createVariableReads(java.util.List<? extends CtVariable<?>> variables) |
Modifier and Type | Method and Description |
---|---|
<T> CtField<T> |
FieldFactory.create(CtType<?> target,
java.util.Set<ModifierKind> modifiers,
CtTypeReference<T> type,
java.lang.String name,
CtExpression<T> defaultExpression)
Creates a field.
|
<T> CtBinaryOperator<T> |
Factory.createBinaryOperator(CtExpression<?> left,
CtExpression<?> right,
BinaryOperatorKind kind) |
<T> CtBinaryOperator<T> |
Factory.createBinaryOperator(CtExpression<?> left,
CtExpression<?> right,
BinaryOperatorKind kind) |
<T> CtBinaryOperator<T> |
CodeFactory.createBinaryOperator(CtExpression<?> left,
CtExpression<?> right,
BinaryOperatorKind kind)
Creates a binary operator.
|
<T> CtBinaryOperator<T> |
CodeFactory.createBinaryOperator(CtExpression<?> left,
CtExpression<?> right,
BinaryOperatorKind kind)
Creates a binary operator.
|
<T> CtBinaryOperator<T> |
FactoryImpl.createBinaryOperator(CtExpression<?> left,
CtExpression<?> right,
BinaryOperatorKind kind) |
<T> CtBinaryOperator<T> |
FactoryImpl.createBinaryOperator(CtExpression<?> left,
CtExpression<?> right,
BinaryOperatorKind kind) |
<T> CtConstructorCall<T> |
Factory.createConstructorCall(CtTypeReference<T> type,
CtExpression<?>... parameters) |
<T> CtConstructorCall<T> |
CodeFactory.createConstructorCall(CtTypeReference<T> type,
CtExpression<?>... parameters)
Creates a constructor call.
|
<T> CtConstructorCall<T> |
FactoryImpl.createConstructorCall(CtTypeReference<T> type,
CtExpression<?>... parameters) |
CtField |
Factory.createField(CtType<?> target,
java.util.Set<ModifierKind> modifiers,
CtTypeReference type,
java.lang.String name,
CtExpression defaultExpression) |
CtField |
FactoryImpl.createField(CtType<?> target,
java.util.Set<ModifierKind> modifiers,
CtTypeReference type,
java.lang.String name,
CtExpression defaultExpression) |
<T> CtInvocation<T> |
Factory.createInvocation(CtExpression<?> target,
CtExecutableReference<T> executable,
CtExpression<?>... arguments) |
<T> CtInvocation<T> |
Factory.createInvocation(CtExpression<?> target,
CtExecutableReference<T> executable,
CtExpression<?>... arguments) |
<T> CtInvocation<T> |
CodeFactory.createInvocation(CtExpression<?> target,
CtExecutableReference<T> executable,
CtExpression<?>... arguments)
Creates an invocation (can be a statement or an expression).
|
<T> CtInvocation<T> |
CodeFactory.createInvocation(CtExpression<?> target,
CtExecutableReference<T> executable,
CtExpression<?>... arguments)
Creates an invocation (can be a statement or an expression).
|
<T> CtInvocation<T> |
FactoryImpl.createInvocation(CtExpression<?> target,
CtExecutableReference<T> executable,
CtExpression<?>... arguments) |
<T> CtInvocation<T> |
FactoryImpl.createInvocation(CtExpression<?> target,
CtExecutableReference<T> executable,
CtExpression<?>... arguments) |
<T> CtInvocation<T> |
Factory.createInvocation(CtExpression<?> target,
CtExecutableReference<T> executable,
java.util.List<CtExpression<?>> arguments) |
<T> CtInvocation<T> |
CodeFactory.createInvocation(CtExpression<?> target,
CtExecutableReference<T> executable,
java.util.List<CtExpression<?>> arguments)
Creates an invocation (can be a statement or an expression).
|
<T> CtInvocation<T> |
FactoryImpl.createInvocation(CtExpression<?> target,
CtExecutableReference<T> executable,
java.util.List<CtExpression<?>> arguments) |
<T> CtLocalVariable<T> |
Factory.createLocalVariable(CtTypeReference<T> type,
java.lang.String name,
CtExpression<T> defaultExpression) |
<T> CtLocalVariable<T> |
CodeFactory.createLocalVariable(CtTypeReference<T> type,
java.lang.String name,
CtExpression<T> defaultExpression)
Creates a local variable declaration.
|
<T> CtLocalVariable<T> |
FactoryImpl.createLocalVariable(CtTypeReference<T> type,
java.lang.String name,
CtExpression<T> defaultExpression) |
CtNewClass<?> |
Factory.createNewClass(CtType<?> superClass,
CtExpression<?>... parameters)
Creates an anonymous class
|
CtNewClass<?> |
FactoryImpl.createNewClass(CtType<?> superClass,
CtExpression<?>... parameters) |
<T> CtNewClass<T> |
CodeFactory.createNewClass(CtType<T> superClass,
CtExpression<?>... parameters)
Creates a new anonymous class.
|
<T> CtExecutableReference<T> |
ConstructorFactory.createReference(CtTypeReference<T> type,
CtExpression<?>... parameters)
Creates a constructor reference.
|
<A,T extends A> |
Factory.createVariableAssignment(CtVariableReference<A> variable,
boolean isStatic,
CtExpression<T> expression) |
<A,T extends A> |
CodeFactory.createVariableAssignment(CtVariableReference<A> variable,
boolean isStatic,
CtExpression<T> expression)
Creates a variable assignment (can be an expression or a statement).
|
<A,T extends A> |
FactoryImpl.createVariableAssignment(CtVariableReference<A> variable,
boolean isStatic,
CtExpression<T> expression) |
Modifier and Type | Method and Description |
---|---|
<T> CtInvocation<T> |
Factory.createInvocation(CtExpression<?> target,
CtExecutableReference<T> executable,
java.util.List<CtExpression<?>> arguments) |
<T> CtInvocation<T> |
CodeFactory.createInvocation(CtExpression<?> target,
CtExecutableReference<T> executable,
java.util.List<CtExpression<?>> arguments)
Creates an invocation (can be a statement or an expression).
|
<T> CtInvocation<T> |
FactoryImpl.createInvocation(CtExpression<?> target,
CtExecutableReference<T> executable,
java.util.List<CtExpression<?>> arguments) |
<T> CtStatementList |
Factory.createVariableAssignments(java.util.List<? extends CtVariable<T>> variables,
java.util.List<? extends CtExpression<T>> expressions) |
<T> CtStatementList |
CodeFactory.createVariableAssignments(java.util.List<? extends CtVariable<T>> variables,
java.util.List<? extends CtExpression<T>> expressions)
Creates a list of statements that contains the assignments of a set of
variables.
|
<T> CtStatementList |
FactoryImpl.createVariableAssignments(java.util.List<? extends CtVariable<T>> variables,
java.util.List<? extends CtExpression<T>> expressions) |
Modifier and Type | Method and Description |
---|---|
<T,E extends CtExpression<?>> |
CtInheritanceScanner.scanCtArrayAccess(CtArrayAccess<T,E> arrayAccess)
Scans an array access (read and write).
|
<T,E extends CtExpression<?>> |
CtInheritanceScanner.scanCtTargetedExpression(CtTargetedExpression<T,E> targetedExpression)
Scans an abstract targeted expression.
|
<T,E extends CtExpression<?>> |
DefaultJavaPrettyPrinter.visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> expression) |
<T,E extends CtExpression<?>> |
CtAbstractVisitor.visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> expression) |
<T,E extends CtExpression<?>> |
CtVisitor.visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> expression)
Visits a reference to an executable.
|
<T,E extends CtExpression<?>> |
CtInheritanceScanner.visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> e) |
<T,E extends CtExpression<?>> |
CtScanner.visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> expression) |
<T,E extends CtExpression<?>> |
CtBiScannerDefault.visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> expression) |
Modifier and Type | Method and Description |
---|---|
protected void |
DefaultJavaPrettyPrinter.enterCtExpression(CtExpression<?> e)
Enters an expression.
|
protected void |
DefaultJavaPrettyPrinter.exitCtExpression(CtExpression<?> e)
Exits an expression.
|
<T> void |
CtInheritanceScanner.scanCtExpression(CtExpression<T> expression)
Scans an abstract expression.
|
Modifier and Type | Method and Description |
---|---|
<T,E extends CtExpression<?>> |
DefaultCoreFactory.createExecutableReferenceExpression() |
Modifier and Type | Method and Description |
---|---|
static <T> CtExpression<T> |
SnippetCompilationHelper.compileExpression(CtCodeSnippetExpression<T> expr) |
Modifier and Type | Method and Description |
---|---|
<T,E extends CtExpression<?>> |
ParentExiter.scanCtTargetedExpression(CtTargetedExpression<T,E> targetedExpression) |
<T,E extends CtExpression<?>> |
ParentExiter.visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> expression) |
Modifier and Type | Method and Description |
---|---|
<T> CtFieldAccess<T> |
JDTTreeBuilderHelper.createFieldAccess(CtVariableReference<T> variableReference,
CtExpression<?> target,
boolean isReadAccess)
Creates variable access from a
CtVariableReference . |
Modifier and Type | Class and Description |
---|---|
class |
CtArrayAccessImpl<T,V extends CtExpression<?>> |
class |
CtExecutableReferenceExpressionImpl<T,E extends CtExpression<?>> |
class |
CtTargetedExpressionImpl<E,T extends CtExpression<?>> |
Modifier and Type | Method and Description |
---|---|
<C extends CtExpression<T>> |
CtExpressionImpl.addTypeCast(CtTypeReference<?> type) |
<C extends CtExpression<T>> |
CtAssignmentImpl.addTypeCast(CtTypeReference<?> type) |
<E extends CtExpression<T>> |
CtCodeSnippetExpressionImpl.compile() |
<C extends CtTargetedExpression<T,CtExpression<?>>> |
CtSuperAccessImpl.setTarget(CtExpression<?> target) |
<C extends CtTargetedExpression<T,CtExpression<?>>> |
CtFieldAccessImpl.setTarget(CtExpression<?> target) |
<C extends CtExpression<T>> |
CtExpressionImpl.setTypeCasts(java.util.List<CtTypeReference<?>> casts) |
<C extends CtExpression<T>> |
CtAssignmentImpl.setTypeCasts(java.util.List<CtTypeReference<?>> casts) |
Modifier and Type | Method and Description |
---|---|
CtExpression<T> |
CtExpressionImpl.clone() |
CtExpression<java.lang.Boolean> |
CtAssertImpl.getAssertExpression() |
CtExpression<T> |
CtAssignmentImpl.getAssigned() |
CtExpression<A> |
CtAssignmentImpl.getAssignment() |
CtExpression<T> |
CtLocalVariableImpl.getAssignment() |
CtExpression<E> |
CtCaseImpl.getCaseExpression() |
CtExpression<java.lang.Boolean> |
CtConditionalImpl.getCondition() |
CtExpression<java.lang.Boolean> |
CtIfImpl.getCondition() |
CtExpression<T> |
CtCatchVariableImpl.getDefaultExpression() |
CtExpression<T> |
CtLocalVariableImpl.getDefaultExpression() |
CtExpression<T> |
CtConditionalImpl.getElseExpression() |
CtExpression<?> |
CtSynchronizedImpl.getExpression() |
CtExpression<?> |
CtForEachImpl.getExpression() |
CtExpression<T> |
CtLambdaImpl.getExpression() |
CtExpression<java.lang.Boolean> |
CtForImpl.getExpression() |
CtExpression<T> |
CtAssertImpl.getExpression() |
CtExpression<?> |
CtYieldStatementImpl.getExpression() |
CtExpression<java.lang.Integer> |
CtArrayAccessImpl.getIndexExpression() |
CtExpression<?> |
CtBinaryOperatorImpl.getLeftHandOperand() |
CtExpression<java.lang.Boolean> |
CtWhileImpl.getLoopingExpression() |
CtExpression<java.lang.Boolean> |
CtDoImpl.getLoopingExpression() |
CtExpression<T> |
CtUnaryOperatorImpl.getOperand() |
CtExpression<R> |
CtReturnImpl.getReturnedExpression() |
CtExpression<?> |
CtBinaryOperatorImpl.getRightHandOperand() |
CtExpression<S> |
CtSwitchExpressionImpl.getSelector() |
CtExpression<S> |
CtSwitchImpl.getSelector() |
CtExpression<?> |
CtSuperAccessImpl.getTarget() |
CtExpression<?> |
CtFieldAccessImpl.getTarget() |
CtExpression<T> |
CtConditionalImpl.getThenExpression() |
CtExpression<? extends java.lang.Throwable> |
CtThrowImpl.getThrownExpression() |
Modifier and Type | Method and Description |
---|---|
java.util.List<CtExpression<?>> |
CtConstructorCallImpl.getArguments() |
java.util.List<CtExpression<?>> |
CtInvocationImpl.getArguments() |
java.util.List<CtExpression<E>> |
CtCaseImpl.getCaseExpressions() |
java.util.List<CtExpression<java.lang.Integer>> |
CtNewArrayImpl.getDimensionExpressions() |
java.util.List<CtExpression<?>> |
CtNewArrayImpl.getElements() |
Modifier and Type | Method and Description |
---|---|
<C extends CtAbstractInvocation<T>> |
CtConstructorCallImpl.addArgument(CtExpression<?> argument) |
<C extends CtAbstractInvocation<T>> |
CtInvocationImpl.addArgument(CtExpression<?> argument) |
<T extends CtCase<E>> |
CtCaseImpl.addCaseExpression(CtExpression<E> caseExpression) |
<C extends CtNewArray<T>> |
CtNewArrayImpl.addDimensionExpression(CtExpression<java.lang.Integer> dimension) |
<C extends CtNewArray<T>> |
CtNewArrayImpl.addElement(CtExpression<?> expression) |
void |
CtConstructorCallImpl.removeArgument(CtExpression<?> argument) |
void |
CtInvocationImpl.removeArgument(CtExpression<?> argument) |
boolean |
CtNewArrayImpl.removeDimensionExpression(CtExpression<java.lang.Integer> dimension) |
boolean |
CtNewArrayImpl.removeElement(CtExpression<?> expression) |
<A extends CtAssert<T>> |
CtAssertImpl.setAssertExpression(CtExpression<java.lang.Boolean> asserted) |
<C extends CtAssignment<T,A>> |
CtAssignmentImpl.setAssigned(CtExpression<T> assigned) |
<C extends CtRHSReceiver<A>> |
CtAssignmentImpl.setAssignment(CtExpression<A> assignment) |
<C extends CtRHSReceiver<T>> |
CtLocalVariableImpl.setAssignment(CtExpression<T> assignment) |
<T extends CtCase<E>> |
CtCaseImpl.setCaseExpression(CtExpression<E> caseExpression) |
<C extends CtConditional<T>> |
CtConditionalImpl.setCondition(CtExpression<java.lang.Boolean> condition) |
<T extends CtIf> |
CtIfImpl.setCondition(CtExpression<java.lang.Boolean> condition) |
<C extends CtVariable<T>> |
CtCatchVariableImpl.setDefaultExpression(CtExpression<T> defaultExpression) |
<C extends CtVariable<T>> |
CtLocalVariableImpl.setDefaultExpression(CtExpression<T> defaultExpression) |
<C extends CtConditional<T>> |
CtConditionalImpl.setElseExpression(CtExpression<T> elseExpression) |
<T extends CtForEach> |
CtForEachImpl.setExpression(CtExpression<?> expression) |
<T extends CtSynchronized> |
CtSynchronizedImpl.setExpression(CtExpression<?> expression) |
<T extends CtYieldStatement> |
CtYieldStatementImpl.setExpression(CtExpression<?> expression) |
<T extends CtFor> |
CtForImpl.setExpression(CtExpression<java.lang.Boolean> expression) |
<A extends CtAssert<T>> |
CtAssertImpl.setExpression(CtExpression<T> value) |
<C extends CtLambda<T>> |
CtLambdaImpl.setExpression(CtExpression<T> expression) |
<C extends CtArrayAccess<T,V>> |
CtArrayAccessImpl.setIndexExpression(CtExpression<java.lang.Integer> expression) |
<C extends CtBinaryOperator<T>> |
CtBinaryOperatorImpl.setLeftHandOperand(CtExpression<?> expression) |
<T extends CtDo> |
CtDoImpl.setLoopingExpression(CtExpression<java.lang.Boolean> expression) |
<T extends CtWhile> |
CtWhileImpl.setLoopingExpression(CtExpression<java.lang.Boolean> expression) |
<C extends CtUnaryOperator> |
CtUnaryOperatorImpl.setOperand(CtExpression<T> expression) |
<T extends CtReturn<R>> |
CtReturnImpl.setReturnedExpression(CtExpression<R> expression) |
<C extends CtBinaryOperator<T>> |
CtBinaryOperatorImpl.setRightHandOperand(CtExpression<?> expression) |
<T extends CtAbstractSwitch<S>> |
CtSwitchExpressionImpl.setSelector(CtExpression<S> selector) |
<T extends CtAbstractSwitch<S>> |
CtSwitchImpl.setSelector(CtExpression<S> selector) |
<C extends CtTargetedExpression<T,CtExpression<?>>> |
CtSuperAccessImpl.setTarget(CtExpression<?> target) |
<C extends CtTargetedExpression<T,CtExpression<?>>> |
CtFieldAccessImpl.setTarget(CtExpression<?> target) |
<C extends CtConditional<T>> |
CtConditionalImpl.setThenExpression(CtExpression<T> thenExpression) |
<T extends CtThrow> |
CtThrowImpl.setThrownExpression(CtExpression<? extends java.lang.Throwable> expression) |
Modifier and Type | Method and Description |
---|---|
<C extends CtAbstractInvocation<T>> |
CtConstructorCallImpl.setArguments(java.util.List<CtExpression<?>> arguments) |
<C extends CtAbstractInvocation<T>> |
CtInvocationImpl.setArguments(java.util.List<CtExpression<?>> arguments) |
<T extends CtCase<E>> |
CtCaseImpl.setCaseExpressions(java.util.List<CtExpression<E>> caseExpressions) |
<C extends CtNewArray<T>> |
CtNewArrayImpl.setDimensionExpressions(java.util.List<CtExpression<java.lang.Integer>> dimensionExpressions) |
<C extends CtNewArray<T>> |
CtNewArrayImpl.setElements(java.util.List<CtExpression<?>> expressions) |
Modifier and Type | Class and Description |
---|---|
class |
CtAnnotationImpl<A extends java.lang.annotation.Annotation>
The implementation for
CtAnnotation . |
Modifier and Type | Method and Description |
---|---|
<T extends CtExpression> |
CtAnnotationImpl.getValue(java.lang.String key) |
<T extends CtExpression> |
CtAnnotationImpl.getWrappedValue(java.lang.String key) |
<C extends CtExpression<A>> |
CtAnnotationImpl.setTypeCasts(java.util.List<CtTypeReference<?>> casts) |
Modifier and Type | Method and Description |
---|---|
CtExpression<T> |
CtFieldImpl.getAssignment() |
CtExpression<T> |
CtEnumValueImpl.getAssignment() |
CtExpression<T> |
CtFieldImpl.getDefaultExpression() |
CtExpression<T> |
CtAnnotationMethodImpl.getDefaultExpression() |
CtExpression<T> |
CtParameterImpl.getDefaultExpression() |
Modifier and Type | Method and Description |
---|---|
java.util.Map<java.lang.String,CtExpression> |
CtAnnotationImpl.getAllValues() |
java.util.Map<java.lang.String,CtExpression> |
CtAnnotationImpl.getValues() |
Modifier and Type | Method and Description |
---|---|
<C extends CtRHSReceiver<T>> |
CtFieldImpl.setAssignment(CtExpression<T> assignment) |
<C extends CtAnnotationMethod<T>> |
CtAnnotationMethodImpl.setDefaultExpression(CtExpression<T> assignedExpression) |
<C extends CtVariable<T>> |
CtFieldImpl.setDefaultExpression(CtExpression<T> defaultExpression) |
<C extends CtVariable<T>> |
CtParameterImpl.setDefaultExpression(CtExpression<T> defaultExpression) |
Modifier and Type | Method and Description |
---|---|
<T extends CtAnnotation<A>> |
CtAnnotationImpl.addValue(java.lang.String elementName,
CtNewArray<? extends CtExpression> value) |
<T extends CtAnnotation<A>> |
CtAnnotationImpl.setValues(java.util.Map<java.lang.String,CtExpression> values) |
Modifier and Type | Method and Description |
---|---|
static java.lang.Object |
EvalHelper.getCorrespondingRuntimeObject(CtExpression<?> value)
Returns the runtime object corresponding to the expression
eg CtLiteral(3) -> 3
|
static boolean |
EvalHelper.isKnownAtCompileTime(CtExpression<?> exp)
returns true if the expression is known at compile time
Bonus method for @oscarlvp :-)
|
Modifier and Type | Method and Description |
---|---|
static java.lang.Integer |
Parameters.getIndex(CtExpression<?> e)
Gets the index of a one-dimension array (helper).
|
Modifier and Type | Method and Description |
---|---|
<T,E extends CtExpression<?>> |
CloneVisitor.visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> expression) |
Modifier and Type | Method and Description |
---|---|
<T,E extends CtExpression<?>> |
ReplacementVisitor.visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> expression) |
Modifier and Type | Method and Description |
---|---|
CtExpression<T> |
ExpressionTemplate.apply(CtType<?> targetType) |
static <T> CtExpression<T> |
ExpressionTemplate.getExpression(CtClass<? extends ExpressionTemplate<?>> p)
Returns the expression.
|
static CtExpression<?> |
Substitution.substituteFieldDefaultExpression(CtType<?> targetType,
Template<?> template,
java.lang.String fieldName)
Gets a default expression from a template field with all the template
parameters substituted.
|
Copyright © 2007–2021 Inria. All rights reserved.