Uses of Annotation Type
spoon.reflect.annotations.PropertyGetter

Packages that use PropertyGetter

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.

Uses of PropertyGetter in spoon.reflect.code

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

Modifier and Type	Method	Description
CtTypeReference<A>	CtTypeAccess.getAccessedType()	Returns type represented and contained in the type access.
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.
CtClass<?>	CtNewClass.getAnonymousClass()	Gets the created class.
List<CtExpression<?>>	CtAbstractInvocation.getArguments()	The arguments of the invocation.
CtExpression<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<A>	CtRHSReceiver.getAssignment()	Returns the right-hand side of the "=" operator.
LiteralBase	CtLiteral.getBase()	Gets the base of the numeric literal (2, 8, 10 or 16).
CtBlock<?>	CtSynchronized.getBlock()	Gets the synchronized block.
CtStatement	CtBodyHolder.getBody()	Gets the body of this element
CtBlock<?>	CtCatch.getBody()	Gets the catch's body.
CtStatement	CtLoop.getBody()	Gets the body of this loop.
CtBlock<?>	CtTry.getBody()	Gets the try body.
CtExpression<S>	CtCase.getCaseExpression()	Gets the case expression.
List<CtExpression<S>>	CtCase.getCaseExpressions()	Gets the case expressions.
CaseKind	CtCase.getCaseKind()	Gets the kind of this case - colon (:) or arrow (->) (Arrow syntax is available as a preview feature since Java 12)
List<CtCase<? super S>>	CtAbstractSwitch.getCases()	Gets the list of cases defined for this switch.
List<CtCatch>	CtTry.getCatchers()	Gets the catchers of this try.
CtComment.CommentType	CtComment.getCommentType()	Get the type of the comment
CtExpression<Boolean>	CtConditional.getCondition()	Gets the condition expression.
CtExpression<Boolean>	CtIf.getCondition()	Gets the boolean expression that represents the if's condition.
String	CtComment.getContent()	Get the content of the comment
String	CtJavaDocTag.getContent()	Get the content of the atg
List<CtExpression<Integer>>	CtNewArray.getDimensionExpressions()	Gets the expressions that define the array's dimensions.
List<CtExpression<?>>	CtNewArray.getElements()	Gets the initialization expressions.
CtExpression<T>	CtConditional.getElseExpression()	Gets the "false" expression.
<S extends CtStatement> S	CtIf.getElseStatement()	Gets the statement executed when the condition is false.
CtExecutableReference<T>	CtAbstractInvocation.getExecutable()	Returns the invoked executable.
CtExecutableReference<T>	CtExecutableReferenceExpression.getExecutable()	Gets the executable referenced by the expression.
CtExpression<T>	CtAssert.getExpression()	Gets the expression of the assertion if defined.
CtExpression<Boolean>	CtFor.getExpression()	Gets the end-loop test expression.
CtExpression<?>	CtForEach.getExpression()	Gets the iterated expression (an iterable of an array).
CtExpression<T>	CtLambda.getExpression()	Gets the expression in the body.
CtExpression<?>	CtSynchronized.getExpression()	Gets the expression that defines the monitored object if any.
CtExpression<?>	CtYieldStatement.getExpression()	Gets the expression of the yield statement.
CtBlock<?>	CtTry.getFinalizer()	Gets the finalizer block of this try ( finally part).
List<CtStatement>	CtFor.getForInit()	Gets the init statements.
List<CtStatement>	CtFor.getForUpdate()	Gets the update statements.
CtExpression<Integer>	CtArrayAccess.getIndexExpression()	Returns the expression that defines the index.
BinaryOperatorKind	CtBinaryOperator.getKind()	Gets the kind of this binary operator.
BinaryOperatorKind	CtOperatorAssignment.getKind()	Gets the operator kind.
UnaryOperatorKind	CtUnaryOperator.getKind()	Gets the kind of this operator.
String	CtStatement.getLabel()	Gets the label of this statement if defined.
CtExpression<?>	CtBinaryOperator.getLeftHandOperand()	Returns the left-hand operand.
CtExpression<Boolean>	CtDo.getLoopingExpression()	Returns the looping test as a boolean expression.
CtExpression<Boolean>	CtWhile.getLoopingExpression()	Gets the looping boolean test expression.
CtExpression<?>	CtUnaryOperator.getOperand()	Gets the expression to which the operator is applied.
String	CtJavaDocTag.getParam()	Get the parameter of the tag return null when none is specified (only for @param and @throws)
CtCatchVariable<? extends Throwable>	CtCatch.getParameter()	Gets the catch's parameter (a throwable).
String	CtJavaDocTag.getRealName()	The type of the tag
List<CtResource<?>>	CtTryWithResource.getResources()	Gets the auto-closeable resources of this try.
CtExpression<R>	CtReturn.getReturnedExpression()	Gets the returned expression.
CtExpression<?>	CtBinaryOperator.getRightHandOperand()	Returns the right-hand operand.
CtExpression<S>	CtAbstractSwitch.getSelector()	Gets the selector.
List<CtStatement>	CtStatementList.getStatements()	Returns the statement list.
List<CtJavaDocTag>	CtJavaDoc.getTags()	Get all the tag of the javadoc
E	CtTargetedExpression.getTarget()	Gets the target expression.
String	CtLabelledFlowBreak.getTargetLabel()	Gets the label from which the control flow breaks (null if no label defined).
CtExpression<T>	CtConditional.getThenExpression()	Gets the "true" expression.
<S extends CtStatement> S	CtIf.getThenStatement()	Gets the statement executed when the condition is true.
CtExpression<? extends Throwable>	CtThrow.getThrownExpression()	Returns the thrown expression (must be a throwable).
CtTypeReference<T>	CtConstructorCall.getType()
CtTypeReference<T>	CtInvocation.getType()	Return the type returned by the invocation.
CtJavaDocTag.TagType	CtJavaDocTag.getType()	The type of the tag
List<CtTypeReference<?>>	CtExpression.getTypeCasts()	Returns the type casts if any.
T	CtLiteral.getValue()	Gets the actual value of the literal (statically known).
CtFieldReference<T>	CtAnnotationFieldAccess.getVariable()
CtFieldReference<T>	CtFieldAccess.getVariable()
CtLocalVariable<?>	CtForEach.getVariable()	Gets the variable that references the currently iterated element.
CtLocalVariable<?>	CtTypePattern.getVariable()	Returns the local variable declared by this type pattern.
CtVariableReference<T>	CtVariableAccess.getVariable()	Gets the reference to the accessed variable.
boolean	CtLocalVariable.isInferred()	Return true if this variable's type is not explicitely defined in the source code, but was using the `var` keyword of Java 10.

Uses of PropertyGetter in spoon.reflect.declaration

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

Modifier and Type	Method	Description
<A extends Annotation> A	CtElement.getAnnotation(Class<A> annotationType)	Searches for an annotation of the given class that annotates the current element.
<A extends Annotation> CtAnnotation<A>	CtElement.getAnnotation(CtTypeReference<A> annotationType)	Gets the annotation element for a given annotation type.
List<CtAnnotation<? extends Annotation>>	CtElement.getAnnotations()	Returns the annotations that are present on this element.
CtTypeReference<A>	CtAnnotation.getAnnotationType()	Returns the annotation type of this annotation.
List<CtAnonymousExecutable>	CtClass.getAnonymousExecutables()	Returns the anonymous blocks of this class.
List<CtComment>	CtElement.getComments()	The list of comments
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.
CtModule	CtCompilationUnit.getDeclaredModule()	Gets the declared module if the compilationUnit is "module-info.java"
CtModuleReference	CtCompilationUnit.getDeclaredModuleReference()	Gets the declared module reference if the compilationUnit is "module-info.java"
List<CtTypeReference<?>>	CtCompilationUnit.getDeclaredTypeReferences()	Gets references to all the types declared in this compilation unit.
List<CtType<?>>	CtCompilationUnit.getDeclaredTypes()	Gets all the types declared in this compilation unit.
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.
CtEnumValue<?>	CtEnum.getEnumValue(String name)	Gets an enum value by its name.
List<CtEnumValue<?>>	CtEnum.getEnumValues()	Gets all enum values of the enumeration.
List<CtPackageExport>	CtModule.getExportedPackages()
Set<CtExtendedModifier>	CtModifiable.getExtendedModifiers()
CtField<?>	CtType.getField(String name)	Gets a field from its name.
List<CtField<?>>	CtType.getFields()	Returns the fields that are directly declared by this class or interface.
List<CtTypeParameter>	CtFormalTypeDeclarer.getFormalCtTypeParameters()	Returns the formal type parameters of this generic element.
List<CtTypeReference>	CtProvidedService.getImplementationTypes()
ModelList<CtImport>	CtCompilationUnit.getImports()	Get the imports computed for this CU.
<R> CtMethod<R>	CtType.getMethod(String name, CtTypeReference<?>... parameterTypes)	Gets a method from its name and parameter types.
<R> CtMethod<R>	CtType.getMethod(CtTypeReference<R> returnType, String name, CtTypeReference<?>... parameterTypes)	Gets a method from its return type, name, and parameter types.
Set<CtMethod<?>>	CtType.getMethods()	Returns the methods that are directly declared by this class or interface.
Set<CtMethod<?>>	CtType.getMethodsAnnotatedWith(CtTypeReference<?>... annotationTypes)	Returns the methods that are directly declared by this class or interface and annotated with one of the given annotations.
List<CtMethod<?>>	CtType.getMethodsByName(String name)	Returns the methods that are directly declared by this class or interface and that have the given name.
Set<ModifierKind>	CtModifiable.getModifiers()	Returns the modifiers of this element, excluding annotations.
Set<ModifierKind>	CtTypeInformation.getModifiers()	Gets modifiers of this type.
List<CtModuleDirective>	CtModule.getModuleDirectives()
CtModuleReference	CtModuleRequirement.getModuleReference()
List<CtTypeReference<?>>	CtMultiTypedElement.getMultiTypes()	Gets all types of the element.
<N extends CtType<?>> N	CtType.getNestedType(String name)	Gets a nested type from its name.
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	CtPackage.getPackage(String name)	Searches a child package by name.
CtPackageDeclaration	CtCompilationUnit.getPackageDeclaration()
CtPackageReference	CtPackageExport.getPackageReference()
Set<CtPackage>	CtPackage.getPackages()	Gets the set of included child packages.
List<CtParameter<?>>	CtExecutable.getParameters()	Gets the parameters list.
Set<CtTypeReference<?>>	CtSealable.getPermittedTypes()	Returns the permitted types for this type.
SourcePosition	CtElement.getPosition()	Gets the position of this element in input source files
List<CtProvidedService>	CtModule.getProvidedServices()
Set<CtRecordComponent>	CtRecord.getRecordComponents()
CtReference	CtImport.getReference()	Returns the reference of the import.
CtPackageReference	CtPackageDeclaration.getReference()	Returns the reference to the package.
List<CtModuleRequirement>	CtModule.getRequiredModules()
Set<CtModuleRequirement.RequiresModifier>	CtModuleRequirement.getRequiresModifiers()
CtPackage	CtModule.getRootPackage()	returns the root package of the unnamed module If there are several modules, it throws an exception
CtTypeReference	CtProvidedService.getServiceType()
CtTypeReference	CtUsedService.getServiceType()
String	CtConstructor.getSimpleName()	Always returns "<init>".
String	CtNamedElement.getSimpleName()	Returns the simple (unqualified) name of this element.
String	CtType.getSimpleName()	Returns the simple (unqualified) name of this element.
CtTypeReference<?>	CtTypeInformation.getSuperclass()	Returns a reference to the type directly extended by this type.
Set<CtTypeReference<?>>	CtTypeInformation.getSuperInterfaces()	Returns the interface types directly implemented by this class or extended by this interface.
List<CtModuleReference>	CtPackageExport.getTargetExport()
Set<CtTypeReference<? extends Throwable>>	CtExecutable.getThrownTypes()	Returns the exceptions and other throwables listed in this method or constructor's throws clause.
<T extends CtType<?>> T	CtPackage.getType(String simpleName)	Finds a top-level type by name.
CtTypeReference<T>	CtTypedElement.getType()	Gets this element's type.
List<CtTypeMember>	CtType.getTypeMembers()	Gets all type members of the type like fields, methods, anonymous block, etc.
Set<CtType<?>>	CtPackage.getTypes()	Returns the set of the top-level types in this package.
List<CtUsedService>	CtModule.getUsedServices()
<T extends CtExpression> T	CtAnnotation.getValue(String key)	Gets a value, as a CtExpression, for a given key without any conversion.
String	CtCodeSnippet.getValue()	Gets the textual value of the code.
Map<String,CtExpression>	CtAnnotation.getValues()	Returns this annotation's elements and their values.
<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.
boolean	CtConstructor.isCompactConstructor()	Checks if the constructor is a compact constructor.
boolean	CtMethod.isDefaultMethod()	Checks if the method is a default method.
boolean	CtElement.isImplicit()	Returns true if this element is not present in the code (automatically added by the Java compiler or inferred when the model is built).
boolean	CtParameter.isInferred()	Returns true if this parameter is a lambda parameter with type defined using the `var` keyword (since Java 11).
boolean	CtPackageExport.isOpenedPackage()
boolean	CtModule.isOpenModule()
boolean	CtShadowable.isShadow()	When an element isn't present in the factory (created in another factory), this element is considered as "shadow".
boolean	CtParameter.isVarArgs()	Returns true if this parameter accepts a variable number of arguments (must be the last parameter of CtExecutable.getParameters()).

Uses of PropertyGetter in spoon.reflect.reference

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

Modifier and Type	Method	Description
List<CtTypeReference<?>>	CtActualTypeContainer.getActualTypeArguments()	Gets the type arguments.
CtTypeReference<?>	CtWildcardReference.getBoundingType()	A type parameter can have an extends clause which declare one (CtTypeReference or more (CtIntersectionTypeReference references.
List<CtTypeReference<?>>	CtIntersectionTypeReference.getBounds()	Gets the bounds of the intersection type.
CtTypeReference<?>	CtArrayTypeReference.getComponentType()	Gets the type of the elements contained in this array.
CtTypeReference<?>	CtExecutableReference.getDeclaringType()	Gets the reference to the type that declares this executable.
CtTypeReference<?>	CtFieldReference.getDeclaringType()	Gets the type in which the field is declared.
CtTypeReference<?>	CtTypeReference.getDeclaringType()	Gets the type that declares the referenced type.
CtPackageReference	CtTypeReference.getPackage()	Gets the package of the referenced type.
List<CtTypeReference<?>>	CtExecutableReference.getParameters()	Gets parameters of the executable.
String	CtReference.getSimpleName()	Gets the simple name of referenced element.
CtTypeReference<T>	CtExecutableReference.getType()	For methods, gets the return type of the executable (may be null in noclasspath mode).
CtTypeReference<T>	CtVariableReference.getType()	Gets the type of the variable.
CtTypeReference<?>	CtTypeMemberWildcardImportReference.getTypeReference()
boolean	CtFieldReference.isFinal()	Tells if the referenced field is final.
boolean	CtExecutableReference.isStatic()	Tells if the referenced executable is static.
boolean	CtFieldReference.isStatic()	Tells if the referenced field is static.
boolean	CtWildcardReference.isUpper()	Returns true if the bounds are in extends clause.