spoon.support.reflect.declaration

Class CtExecutableImpl<R>

java.lang.Object

spoon.support.reflect.declaration.CtElementImpl

spoon.support.reflect.declaration.CtNamedElementImpl

spoon.support.reflect.declaration.CtExecutableImpl<R>

All Implemented Interfaces:

java.io.Serializable, java.lang.Cloneable, FactoryAccessor, CtBodyHolder, SourcePositionHolder, CtElement, CtExecutable<R>, CtNamedElement, CtTypedElement<R>, CtQueryable, CtVisitable

Direct Known Subclasses:

CtAnonymousExecutableImpl, CtConstructorImpl, CtMethodImpl

public abstract class CtExecutableImpl<R>
extends CtNamedElementImpl
implements CtExecutable<R>

The implementation for CtExecutable.

Author:

Renaud Pawlak

See Also:

Serialized Form

Field Summary

Fields inherited from class spoon.support.reflect.declaration.CtElementImpl

ERROR_MESSAGE_TO_STRING, factory, LOGGER, parent

Fields inherited from interface spoon.reflect.declaration.CtExecutable

EXECUTABLE_SEPARATOR

Constructor Summary

Constructors

Constructor and Description
CtExecutableImpl()

Method Summary

Modifier and Type	Method and Description
<T extends CtExecutable<R>> T	addParameter(CtParameter<?> parameter) Add a parameter for this executable
<T extends CtExecutable<R>> T	addParameterAt(int position, CtParameter<?> parameter) Add a parameter at a specific position in the executable.
<T extends CtExecutable<R>> T	addThrownType(CtTypeReference<? extends java.lang.Throwable> throwType) add a thrown type.
CtExecutable<R>	clone() Clone the element which calls this method in a new object.
CtBlock<R>	getBody() Gets the body expression.
CtType<?>	getDeclaringType()
java.util.List<CtParameter<?>>	getParameters() Gets the parameters list.
CtExecutableReference<R>	getReference() Returns the corresponding reference.
java.lang.String	getSignature() Gets the signature of this method or constructor.
java.util.Set<CtTypeReference<? extends java.lang.Throwable>>	getThrownTypes() Returns the exceptions and other throwables listed in this method or constructor's throws clause.
<T> CtType<T>	getTopLevelType()
boolean	removeParameter(CtParameter<?> parameter) Remove a parameter for this executable
boolean	removeThrownType(CtTypeReference<? extends java.lang.Throwable> throwType) remove a thrown type.
<T extends CtBodyHolder> T	setBody(CtStatement statement) Sets the body of this element.
<T extends CtExecutable<R>> T	setParameters(java.util.List<CtParameter<?>> parameters) Sets the parameters.
<T extends CtExecutable<R>> T	setThrownTypes(java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes) Sets the thrown types.

Methods inherited from class spoon.support.reflect.declaration.CtNamedElementImpl

getSimpleName, setSimpleName

Methods inherited from class spoon.support.reflect.declaration.CtElementImpl

addAnnotation, addComment, asIterable, comment, delete, descendantIterator, emptyList, emptySet, equals, filterChildren, getAllMetadata, getAnnotatedChildren, getAnnotation, getAnnotation, getAnnotations, getComments, getDirectChildren, getDocComment, getElements, getFactory, getMetadata, getMetadataKeys, getOriginalSourceFragment, getParent, getParent, getParent, getPath, getPosition, getReferencedTypes, getRoleInParent, getShortRepresentation, getValueByRole, hasAnnotation, hashCode, hasParent, isImplicit, isParentInitialized, map, map, prettyprint, putMetadata, removeAnnotation, removeComment, replace, replace, setAllMetadata, setAnnotations, setComments, setDocComment, setFactory, setImplicit, setParent, setPosition, setPositions, setValueByRole, toString, toStringDebug, unmodifiableList, updateAllParentsBelow

Methods inherited from class java.lang.Object

finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface spoon.reflect.declaration.CtNamedElement

getSimpleName, setSimpleName

Methods inherited from interface spoon.reflect.declaration.CtTypedElement

getType, setType

Methods inherited from interface spoon.reflect.declaration.CtElement

addAnnotation, addComment, asIterable, delete, descendantIterator, getAllMetadata, getAnnotatedChildren, getAnnotation, getAnnotation, getAnnotations, getComments, getDirectChildren, getDocComment, getElements, getMetadata, getMetadataKeys, getOriginalSourceFragment, getParent, getParent, getParent, getPath, getPosition, getReferencedTypes, getRoleInParent, getShortRepresentation, getValueByRole, hasAnnotation, hasParent, isImplicit, isParentInitialized, prettyprint, putMetadata, removeAnnotation, removeComment, replace, replace, setAllMetadata, setAnnotations, setComments, setDocComment, setImplicit, setParent, setPosition, setPositions, setValueByRole, toString, toStringDebug, updateAllParentsBelow

Methods inherited from interface spoon.processing.FactoryAccessor

getFactory, setFactory

Methods inherited from interface spoon.reflect.visitor.CtVisitable

accept

Methods inherited from interface spoon.reflect.visitor.chain.CtQueryable

filterChildren, map, map

Constructor Detail

CtExecutableImpl

public CtExecutableImpl()

Method Detail

getDeclaringType

public CtType<?> getDeclaringType()

getTopLevelType

public <T> CtType<T> getTopLevelType()

getBody

public CtBlock<R> getBody()

Description copied from interface: CtExecutable

Gets the body expression.

Specified by:

getBody in interface CtBodyHolder

Specified by:

getBody in interface CtExecutable<R>

setBody

public <T extends CtBodyHolder> T setBody(CtStatement statement)

Description copied from interface: CtBodyHolder

Sets the body of this element. If body is not a block, it is wrapped in a CtBlock which is semantically equivalent and eases transformation afterwards if required.

Specified by:

setBody in interface CtBodyHolder

getParameters

public java.util.List<CtParameter<?>> getParameters()

Description copied from interface: CtExecutable

Gets the parameters list.

Specified by:

getParameters in interface CtExecutable<R>

setParameters

public <T extends CtExecutable<R>> T setParameters(java.util.List<CtParameter<?>> parameters)

Description copied from interface: CtExecutable

Sets the parameters.

Specified by:

setParameters in interface CtExecutable<R>

addParameter

public <T extends CtExecutable<R>> T addParameter(CtParameter<?> parameter)

Description copied from interface: CtExecutable

Add a parameter for this executable

Specified by:

addParameter in interface CtExecutable<R>

Returns:

true if this element changed as a result of the call

addParameterAt

public <T extends CtExecutable<R>> T addParameterAt(int position,
                                                    CtParameter<?> parameter)

Description copied from interface: CtExecutable

Add a parameter at a specific position in the executable.

Specified by:

addParameterAt in interface CtExecutable<R>

Parameters:

position - index where the `parameter` needs to be inserted

parameter - parameter to be inserted

Returns:

an object or sub-type of CtExecutable

removeParameter

public boolean removeParameter(CtParameter<?> parameter)

Description copied from interface: CtExecutable

Remove a parameter for this executable

Specified by:

removeParameter in interface CtExecutable<R>

Returns:

true if this element changed as a result of the call

getThrownTypes

public java.util.Set<CtTypeReference<? extends java.lang.Throwable>> getThrownTypes()

Description copied from interface: CtExecutable

Returns the exceptions and other throwables listed in this method or constructor's throws clause.

Specified by:

getThrownTypes in interface CtExecutable<R>

setThrownTypes

public <T extends CtExecutable<R>> T setThrownTypes(java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes)

Description copied from interface: CtExecutable

Sets the thrown types.

Specified by:

setThrownTypes in interface CtExecutable<R>

addThrownType

public <T extends CtExecutable<R>> T addThrownType(CtTypeReference<? extends java.lang.Throwable> throwType)

Description copied from interface: CtExecutable

add a thrown type.

Specified by:

addThrownType in interface CtExecutable<R>

Returns:

true if this element changed as a result of the call

removeThrownType

public boolean removeThrownType(CtTypeReference<? extends java.lang.Throwable> throwType)

Description copied from interface: CtExecutable

remove a thrown type.

Specified by:

removeThrownType in interface CtExecutable<R>

Returns:

true if this element changed as a result of the call

getSignature

public java.lang.String getSignature()

Description copied from interface: CtExecutable

Gets the signature of this method or constructor. The signature is composed of the method name and the parameter types, all fully-qualified, eg "int foo(java.lang.String)". The core contract is that in a type, there cannot be two methods with the same signature. Note that the concept of method signature in Java is not well defined (see chapter "8.4.2 Method Signature" of the Java specification, which defines what relations between signatures but not what a signature is exactly). Note also that the signature of a method reference is the same as the signature of the corresponding method if and only if the method parameters does not involve generics in their types. Otherwise, one has eg m(String) (reference) and m(T) (declaration) Reference: "In the Java programming language, a method signature is the method name and the number and type of its parameters. Return types and thrown exceptions are not considered to be a part of the method signature." see https://stackoverflow.com/questions/16149285/does-a-methods-signature-in-java-include-its-return-type see https://en.wikipedia.org/wiki/Type_signature

Specified by:

getSignature in interface CtExecutable<R>

getReference

public CtExecutableReference<R> getReference()

Description copied from interface: CtNamedElement

Returns the corresponding reference.

Specified by:

getReference in interface CtExecutable<R>

Specified by:

getReference in interface CtNamedElement

Overrides:

getReference in class CtNamedElementImpl

clone

public CtExecutable<R> clone()

Description copied from interface: CtElement

Clone the element which calls this method in a new object. Note that that references are kept as is, and thus, so if you clone whole classes or methods, some parts of the cloned element (eg executable references) may still point to the initial element. In this case, consider using methods Refactoring.copyType(CtType) and Refactoring.copyMethod(CtMethod) instead which does additional work beyond cloning.

Specified by:

clone in interface CtElement

Specified by:

clone in interface CtExecutable<R>

Specified by:

clone in interface CtNamedElement

Overrides:

clone in class CtNamedElementImpl