Uses of Annotation Type
spoon.support.DerivedProperty

Packages that use DerivedProperty

Package	Description
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.reference	This package defines the references to program elements for the meta-model.
spoon.support.reflect.code
spoon.support.reflect.declaration
spoon.support.reflect.reference

Uses of DerivedProperty in spoon.reflect.code

Methods in spoon.reflect.code with annotations of type DerivedProperty

Modifier and Type	Method	Description
List<CtTypeReference<?>>	CtConstructorCall.getActualTypeArguments()	Delegate to the executable reference of the constructor call.
List<CtTypeReference<?>>	CtInvocation.getActualTypeArguments()	Delegate to the executable reference of the invocation.
List<CtTypeReference<?>>	CtNewClass.getActualTypeArguments()	Delegate to the executable reference of the new class.
CtExpression<T>	CtLocalVariable.getAssignment()	Useful proxy to CtVariable.getDefaultExpression().
List<JavadocDescriptionElement>	CtJavaDoc.getJavadocElements()	Returns the list of parsed Javadoc elements
CtStatement	CtLabelledFlowBreak.getLabelledStatement()
<T extends CtStatement> T	CtStatementList.getLastStatement()	Gets the last statement of this block.
String	CtJavaDoc.getLongDescription()	Get the long description of the javadoc
<R> CtMethod<R>	CtLambda.getOverriddenMethod()
String	CtComment.getRawContent()
CtCatchVariableReference<T>	CtCatchVariable.getReference()
CtLocalVariableReference<T>	CtLocalVariable.getReference()
String	CtJavaDoc.getShortDescription()	Get the short summary of the javadoc (first sentence of the javadoc)
<T extends CtStatement> T	CtStatementList.getStatement(int i)	Gets the ith statement of this block.
CtTypeReference<T>	CtCatchVariable.getType()	Returns type reference of the exception variable in a catch.
CtTypeReference<T>	CtConstructorCall.getType()
CtTypeReference<T>	CtInvocation.getType()	Return the type returned by the invocation.
CtTypeReference<T>	CtSuperAccess.getType()
CtTypeReference<Void>	CtTypeAccess.getType()	Returns always VOID.
CtTypeReference<T>	CtVariableAccess.getType()
<T extends CtStatementList> T	CtStatementList.insertAfter(Filter<? extends CtStatement> insertionPoints, CtStatement statement)	Inserts the given statement after a set of insertion points given by a filter.
<T extends CtStatementList> T	CtStatementList.insertAfter(Filter<? extends CtStatement> insertionPoints, CtStatementList statements)	Inserts the given statement list after a set of insertion points given by a filter.
<T extends CtStatementList> T	CtStatementList.insertBefore(Filter<? extends CtStatement> insertionPoints, CtStatement statement)	Inserts the given statement before a set of insertion points given by a filter.
<T extends CtStatementList> T	CtStatementList.insertBefore(Filter<? extends CtStatement> insertionPoints, CtStatementList statements)	Inserts the given statement list before a set of insertion points given by a filter.
boolean	CtTypeAccess.isImplicit()
<E extends CtElement> E	CtTypeAccess.setImplicit(boolean implicit)	Calls CtTypeAccess.getAccessedType().setImplicit()

Uses of DerivedProperty in spoon.reflect.declaration

Methods in spoon.reflect.declaration with annotations of type DerivedProperty

Modifier and Type	Method	Description
CtCompilationUnit	CtCompilationUnit.addDeclaredType(CtType<?> type)	Add a type to the list of declared types.
<T extends CtModule> T	CtModule.addExportedPackage(CtPackageExport exportedPackage)
<T extends CtModule> T	CtModule.addOpenedPackage(CtPackageExport openedPackage)
<T extends CtModule> T	CtModule.addProvidedService(CtProvidedService providedService)
<T extends CtModule> T	CtModule.addRequiredModule(CtModuleRequirement requiredModule)
<T extends CtModule> T	CtModule.addUsedService(CtUsedService usedService)
A	CtAnnotation.getActualAnnotation()	Returns the actual annotation (a dynamic proxy for this element).
Class<T>	CtType.getActualClass()	This is a low-level feature, it should never been used by non advanced users.
Collection<CtExecutableReference<?>>	CtTypeInformation.getAllExecutables()	Gets the executables declared by this type and by all its supertypes (static/instance methods, constructors, anonymous static blocks) if applicable.
Collection<CtFieldReference<?>>	CtTypeInformation.getAllFields()	Gets the fields declared by this type and by all its supertypes if applicable.
Set<CtMethod<?>>	CtType.getAllMethods()	Return all the methods that can be called on an instance of this type.
Map<String,CtExpression>	CtAnnotation.getAllValues()	Get all values of CtAnnotation.getValues(), plus the default ones defined in the annotation type.
CtElement	CtAnnotation.getAnnotatedElement()	Returns the element which is annotated by this annotation.
CtAnnotatedElementType	CtAnnotation.getAnnotatedElementType()	Returns the type of the element which is annotated by this annotation.
Set<CtAnnotationMethod<?>>	CtAnnotationType.getAnnotationMethods()
List<CtAnonymousExecutable>	CtClass.getAnonymousExecutables()	Returns the anonymous blocks of this class.
CtExpression<T>	CtField.getAssignment()	Useful proxy to CtVariable.getDefaultExpression().
CtConstructor<T>	CtClass.getConstructor(CtTypeReference<?>... parameterTypes)	Returns the constructor of the class that takes the given argument types.
Set<CtConstructor<T>>	CtClass.getConstructors()	Returns the constructors of this class.
Collection<CtExecutableReference<?>>	CtTypeInformation.getDeclaredExecutables()	Gets the executables declared by this type if applicable.
Collection<CtFieldReference<?>>	CtTypeInformation.getDeclaredFields()	Gets the fields declared by this type.
CtModule	CtCompilationUnit.getDeclaredModule()	Gets the declared module if the compilationUnit is "module-info.java"
CtPackage	CtCompilationUnit.getDeclaredPackage()	Gets the declared package
List<CtType<?>>	CtCompilationUnit.getDeclaredTypes()	Gets all the types declared in this compilation unit.
CtModule	CtPackage.getDeclaringModule()	Gets the declaring module.
CtPackage	CtPackage.getDeclaringPackage()	Gets the declaring package of the current one.
CtType<?>	CtTypeMember.getDeclaringType()	Gets the type that declares this class member.
String	CtElement.getDocComment()	Returns the text of the documentation ("javadoc") comment of this element.
List<CtPackageExport>	CtModule.getExportedPackages()
List<CtField<?>>	CtType.getFields()	Returns the fields that are directly declared by this class or interface.
CtImportKind	CtImport.getImportKind()	Returns the kind of import (see CtImportKind)
CtType<?>	CtCompilationUnit.getMainType()	Searches and returns the main type (the type which has the same name as the file).
Set<CtMethod<?>>	CtType.getMethods()	Returns the methods that are directly declared by this class or interface.
String	CtAnnotation.getName()	Returns the class name of the annotation, eg "Deprecated" for @Deprecated.
Set<CtType<?>>	CtType.getNestedTypes()	Returns the declarations of the nested classes and interfaces that are directly declared by this class or interface.
List<CtPackageExport>	CtModule.getOpenedPackages()
CtPackage	CtType.getPackage()	Gets the package where this type is declared.
CtElement	CtCompilationUnit.getParent()
CtElement	CtElement.getParent()	Gets the parent of current reference.
CtExecutable<?>	CtParameter.getParent()	Gets the executable that is the parent declaration of this parameter declaration.
Set<CtTypeReference<?>>	CtEnum.getPermittedTypes()
List<CtProvidedService>	CtModule.getProvidedServices()
String	CtTypeInformation.getQualifiedName()	Returns the fully qualified name of this type declaration.
CtExecutableReference<R>	CtExecutable.getReference()
CtFieldReference<T>	CtField.getReference()
CtModuleReference	CtModule.getReference()
CtReference	CtNamedElement.getReference()	Returns the corresponding reference.
CtPackageReference	CtPackage.getReference()
CtParameterReference<T>	CtParameter.getReference()	overriding the return type
CtTypeReference<T>	CtType.getReference()	Returns the corresponding type reference.
CtTypeParameterReference	CtTypeParameter.getReference()	override the return type
CtVariableReference<T>	CtVariable.getReference()
Set<CtTypeReference<?>>	CtElement.getReferencedTypes()	Calculates and returns the set of all the types referenced by this element (and sub-elements in the AST).
List<CtModuleRequirement>	CtModule.getRequiredModules()
String	CtElement.getShortRepresentation()	Build a short representation of any element.
<T> CtType<T>	CtTypeMember.getTopLevelType()	Returns the top level type declaring this type if an inner type or type member.
CtTypeReference<?>	CtTypeInformation.getTypeErasure()	This method returns a reference to the erased type.
CtFormalTypeDeclarer	CtTypeParameter.getTypeParameterDeclarer()
List<CtUsedService>	CtModule.getUsedServices()
int	CtAnnotation.getValueAsInt(String key)	Returns the actual value of an annotation property, as an integer (utility method)
Object	CtAnnotation.getValueAsObject(String key)	Returns the actual value of an annotation property
String	CtAnnotation.getValueAsString(String key)	Returns the actual value of an annotation property, as a String (utility method)
ModifierKind	CtModifiable.getVisibility()	Gets the visibility of this modifiable element.
<T extends CtExpression> T	CtAnnotation.getWrappedValue(String key)	Gets a value for a given key and try to fix its type based on the annotation type.
<A extends Annotation> boolean	CtElement.hasAnnotation(Class<A> annotationType)
boolean	CtModifiable.isAbstract()	Returns true if it contains an abstract modifier (see CtModifiable.hasModifier(ModifierKind))
boolean	CtModifiable.isFinal()	Returns true if it contains a final modifier (see CtModifiable.hasModifier(ModifierKind))
boolean	CtTypeInformation.isGenerics()	Returns true if it is not a concrete, resolvable class, it if refers to a type parameter directly or indirectly.
boolean	CtModifiable.isNative()	Returns true if it contains a native modifier (see CtModifiable.hasModifier(ModifierKind))
boolean	CtTypeInformation.isParameterized()	Returns true if it has any type parameter (generic or not).
boolean	CtVariable.isPartOfJointDeclaration()	Returns true it the variable (field, localvariable) is jointly declared with a share type Eg int a,b; Warning: is computed on demand
boolean	CtModifiable.isPrivate()	Returns true if it contains a private modifier (see CtModifiable.hasModifier(ModifierKind))
boolean	CtModifiable.isProtected()	Returns true if it contains a protected modifier (see CtModifiable.hasModifier(ModifierKind))
boolean	CtModifiable.isPublic()	Returns true if it contains a public modifier (see CtModifiable.hasModifier(ModifierKind))
boolean	CtModifiable.isStatic()	Returns true if it contains a static modifier (see CtModifiable.hasModifier(ModifierKind))
boolean	CtModifiable.isStrictfp()	Returns true if it contains a strictfp modifier (see CtModifiable.hasModifier(ModifierKind))
boolean	CtModifiable.isSynchronized()	Returns true if it contains a synchronized modifier (see CtModifiable.hasModifier(ModifierKind))
boolean	CtModifiable.isTransient()	Returns true if it contains a transient modifier (see CtModifiable.hasModifier(ModifierKind))
boolean	CtModule.isUnnamedModule()	Returns true if the module is the unnamed module
boolean	CtModifiable.isVolatile()	Returns true if it contains a volatile modifier (see CtModifiable.hasModifier(ModifierKind))
<T extends CtModule> T	CtModule.removeExportedPackage(CtPackageExport exportedPackage)
<T extends CtModule> T	CtModule.removeOpenedPackage(CtPackageExport openedPackage)
<T extends CtModule> T	CtModule.removeProvidedService(CtProvidedService providedService)
<T extends CtModule> T	CtModule.removeRequiredModule(CtModuleRequirement requiredModule)
<T extends CtModule> T	CtModule.removeUsedService(CtUsedService usedService)
CtCompilationUnit	CtCompilationUnit.setDeclaredModule(CtModule module)	Sets the declared module if the compilationUnit is "module-info.java" It is here for backward compatibility.
CtCompilationUnit	CtCompilationUnit.setDeclaredPackage(CtPackage ctPackage)	Sets the package declaration using the instance of CtPackage.
CtCompilationUnit	CtCompilationUnit.setDeclaredTypes(List<CtType<?>> types)	Sets the types declared in this compilation unit.
<T extends CtModule> T	CtModule.setExportedPackages(List<CtPackageExport> exportedPackages)
<T extends CtModule> T	CtModule.setOpenedPackages(List<CtPackageExport> openedPackages)
<T extends CtModule> T	CtModule.setProvidedServices(List<CtProvidedService> providedServices)
<T extends CtModule> T	CtModule.setRequiredModules(List<CtModuleRequirement> requiredModules)
<T extends CtModule> T	CtModule.setUsedServices(List<CtUsedService> usedServices)
String	CtType.toStringWithImports()	Gets the entire class code with package and imports.

Uses of DerivedProperty in spoon.reflect.reference

Methods in spoon.reflect.reference with annotations of type DerivedProperty

Modifier and Type	Method	Description
CtTypeReference<?>	CtTypeReference.getAccessType()	Computes nearest access path parent to this type from the context of this type reference.
List<CtAnnotation<? extends Annotation>>	CtTypeMemberWildcardImportReference.getAnnotations()
CtTypeReference<?>	CtArrayTypeReference.getArrayType()	Gets the type of the array elements at the finest grain.
CtTypeReference<?>	CtTypeParameterReference.getBoundingType()	A type parameter can have an extends clause which declare one (CtTypeReference or more (CtIntersectionTypeReference references.
CtCatchVariable<T>	CtCatchVariableReference.getDeclaration()
CtExecutable<T>	CtExecutableReference.getDeclaration()
CtField<T>	CtFieldReference.getDeclaration()
CtLocalVariable<T>	CtLocalVariableReference.getDeclaration()
CtModule	CtModuleReference.getDeclaration()
CtPackage	CtPackageReference.getDeclaration()	Gets the package element when available in the source code.
CtParameter<T>	CtParameterReference.getDeclaration()
CtElement	CtReference.getDeclaration()	Returns the declaration that corresponds to the referenced element only if the declaration is in the analyzed source files.
CtType<?>	CtTypeMemberWildcardImportReference.getDeclaration()
CtTypeParameter	CtTypeParameterReference.getDeclaration()	Returns the CtTypeParameter, a CtTypeParameter, that declares the type parameter referenced or null if the reference is not in a context where such type parameter is declared.
CtType<T>	CtTypeReference.getDeclaration()	Returns the CtType, that corresponds to the reference or null if the type declaration is not in the analyzed source files, CtTypeReference.getTypeDeclaration() is a newer and better alternative that less often returns null.
CtVariable<T>	CtVariableReference.getDeclaration()	Tries to get the declaration of the reference.
CtExecutableReference<?>	CtParameterReference.getDeclaringExecutable()	Gets the declaring executable of the referenced parameter.
int	CtArrayTypeReference.getDimensionCount()	Returns the number of dimensions of this array type.
CtExecutable<T>	CtExecutableReference.getExecutableDeclaration()	Returns a subtype CtExecutable that corresponds to the reference even if its declaring type isn't in the Spoon source path (in this case, the Spoon elements are built with runtime reflection).
CtField<T>	CtFieldReference.getFieldDeclaration()	Returns the CtField that corresponds to the reference even if its declaring type isn't in the Spoon source path (in this case, the Spoon elements are built with runtime reflection)
Set<ModifierKind>	CtTypeReference.getModifiers()
CtExecutableReference<?>	CtExecutableReference.getOverridingExecutable()	Returns the method overridden by this one, if exists (null otherwise).
String	CtArrayTypeReference.getSimpleName()	Returns the simple name of the array type core component type (with no []s).
String	CtTypeMemberWildcardImportReference.getSimpleName()	Returns the fully qualified name of type followed by `.*`
CtTypeReference<?>	CtTypeReference.getSuperclass()
Set<CtTypeReference<?>>	CtTypeReference.getSuperInterfaces()
CtTypeReference<?>	CtTypeReference.getTopLevelType()	Returns this, or top level type of this, if this is an inner type
CtType<T>	CtTypeReference.getTypeDeclaration()	Returns the CtType that corresponds to the reference even if the type isn't in the Spoon source path (in this case, the Spoon elements are built with runtime reflection, and the resulting CtType is called a "shadow" class, see CtShadowable.isShadow()).
CtTypeParameter	CtTypeReference.getTypeParameterDeclaration()	If this type reference is used as a type argument (see CtActualTypeContainer.getActualTypeArguments()), returns the type parameter declaration in the target type, returns null otherwise.
boolean	CtTypeParameterReference.isDefaultBoundingType()	Returns true if this has the default bounding type that is java.lang.Object (which basically means that there is no bound)
boolean	CtTypeMemberWildcardImportReference.isImplicit()
boolean	CtTypeReference.isSimplyQualified()
CtTypeReference<T>	CtTypeReference.setSimplyQualified(boolean isSimplyQualified)

Uses of DerivedProperty in spoon.support.reflect.code

Methods in spoon.support.reflect.code with annotations of type DerivedProperty

Modifier and Type	Method	Description
<T extends CtActualTypeContainer> T	CtConstructorCallImpl.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)
List<CtTypeReference<?>>	CtConstructorCallImpl.getActualTypeArguments()
CtExpression<T>	CtLocalVariableImpl.getAssignment()
CtExpression<T>	CtCatchVariableImpl.getDefaultExpression()
CtTypeReference<T>	CtCatchVariableImpl.getType()
CtTypeReference<T>	CtConstructorCallImpl.getType()
CtTypeReference<T>	CtInvocationImpl.getType()
CtTypeReference<T>	CtVariableAccessImpl.getType()
boolean	CtTypeAccessImpl.isImplicit()
boolean	CtConstructorCallImpl.removeActualTypeArgument(CtTypeReference<?> actualTypeArgument)
<T extends CtActualTypeContainer> T	CtConstructorCallImpl.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)
<E extends CtElement> E	CtTypeAccessImpl.setImplicit(boolean implicit)
<C extends CtTypedElement> C	CtConstructorCallImpl.setType(CtTypeReference type)
<C extends CtTypedElement> C	CtInvocationImpl.setType(CtTypeReference type)
<C extends CtTypedElement> C	CtVariableAccessImpl.setType(CtTypeReference type)

Uses of DerivedProperty in spoon.support.reflect.declaration

Methods in spoon.support.reflect.declaration with annotations of type DerivedProperty

Modifier and Type	Method	Description
CtCompilationUnitImpl	CtCompilationUnitImpl.addDeclaredType(CtType<?> type)
Collection<CtExecutableReference<?>>	CtTypeParameterImpl.getAllExecutables()
Set<CtMethod<?>>	CtTypeParameterImpl.getAllMethods()
CtExpression<T>	CtEnumValueImpl.getAssignment()
CtExpression<T>	CtFieldImpl.getAssignment()
CtBlock<T>	CtAnnotationMethodImpl.getBody()
Collection<CtExecutableReference<?>>	CtTypeParameterImpl.getDeclaredExecutables()
CtModule	CtCompilationUnitImpl.getDeclaredModule()
CtPackage	CtCompilationUnitImpl.getDeclaredPackage()
CtExpression<T>	CtParameterImpl.getDefaultExpression()
List<CtField<?>>	CtEnumImpl.getFields()
List<CtField<?>>	CtTypeParameterImpl.getFields()
List<CtTypeParameter>	CtAnnotationMethodImpl.getFormalCtTypeParameters()
List<CtTypeParameter>	CtAnnotationTypeImpl.getFormalCtTypeParameters()
List<CtTypeParameter>	CtEnumImpl.getFormalCtTypeParameters()
List<CtTypeParameter>	CtTypeParameterImpl.getFormalCtTypeParameters()
Set<CtMethod<?>>	CtTypeParameterImpl.getMethods()
Set<CtType<?>>	CtTypeParameterImpl.getNestedTypes()
CtPackage	CtTypeParameterImpl.getPackage()
List<CtParameter<?>>	CtAnnotationMethodImpl.getParameters()
List<CtParameter<?>>	CtAnonymousExecutableImpl.getParameters()
CtElement	CtModuleImpl.getParent()
Set<CtTypeReference<?>>	CtEnumImpl.getPermittedTypes()
Set<CtTypeReference<?>>	CtElementImpl.getReferencedTypes()
CtTypeReference<?>	CtAnnotationTypeImpl.getSuperclass()
CtTypeReference<?>	CtEnumImpl.getSuperclass()
CtTypeReference<?>	CtRecordImpl.getSuperclass()
CtTypeReference<?>	CtTypeImpl.getSuperclass()
Set<CtTypeReference<?>>	CtAnnotationTypeImpl.getSuperInterfaces()
Set<CtTypeReference<?>>	CtTypeParameterImpl.getSuperInterfaces()
Set<CtTypeReference<? extends Throwable>>	CtAnnotationMethodImpl.getThrownTypes()
Set<CtTypeReference<? extends Throwable>>	CtAnonymousExecutableImpl.getThrownTypes()
CtTypeReference<Void>	CtAnonymousExecutableImpl.getType()
CtTypeReference<T>	CtConstructorImpl.getType()
List<CtTypeReference<?>>	CtAnnotationImpl.getTypeCasts()
List<CtTypeMember>	CtTypeParameterImpl.getTypeMembers()
<F> boolean	CtTypeParameterImpl.removeField(CtField<F> field)
CtCompilationUnit	CtCompilationUnitImpl.setDeclaredTypes(List<CtType<?>> types)
<T extends CtElement> T	CtModuleImpl.setParent(CtElement parent)

Uses of DerivedProperty in spoon.support.reflect.reference

Methods in spoon.support.reflect.reference with annotations of type DerivedProperty

Modifier and Type	Method	Description
List<CtTypeReference<?>>	CtTypeParameterReferenceImpl.getActualTypeArguments()
List<CtAnnotation<? extends Annotation>>	CtTypeMemberWildcardImportReferenceImpl.getAnnotations()
List<CtAnnotation<? extends Annotation>>	CtUnboundVariableReferenceImpl.getAnnotations()
CtTypeReference<?>	CtTypeParameterReferenceImpl.getBoundingType()
CtType<?>	CtTypeMemberWildcardImportReferenceImpl.getDeclaration()
boolean	CtTypeMemberWildcardImportReferenceImpl.isImplicit()
boolean	CtTypeReferenceImpl.isSimplyQualified()
CtTypeReferenceImpl<T>	CtTypeReferenceImpl.setSimplyQualified(boolean isSimplyQualified)