Uses of Annotation Type
spoon.reflect.annotations.PropertyGetter
Packages that use PropertyGetter
Package
Description
This package contains the meta-model part that models the executable code (methods and constructors' bodies, field initializers).
This package contains the meta-model part that models the declarations (program's structures such as classes, fields, etc).
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 PropertyGetterModifier and TypeMethodDescriptionCtTypeAccess.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.CtAssert.getAssertExpression()
Gets the assert expression.CtAssignment.getAssigned()
Returns the assigned expression on the left-hand side (where the value is stored, e.g.CtRHSReceiver.getAssignment()
Returns the right-hand side of the "=" operator.CtLiteral.getBase()
Gets the base of the numeric literal (2, 8, 10 or 16).CtBlock<?>
CtSynchronized.getBlock()
Gets the synchronized block.CtBodyHolder.getBody()
Gets the body of this elementCtBlock<?>
CtCatch.getBody()
Gets the catch's body.CtLoop.getBody()
Gets the body of this loop.CtBlock<?>
CtTry.getBody()
Gets the try body.CtCase.getCaseExpression()
Gets the case expression.CtCase.getCaseExpressions()
Gets the case expressions.CtCase.getCaseKind()
Gets the kind of this case - colon (:) or arrow (->) (Arrow syntax is available as a preview feature since Java 12)CtAbstractSwitch.getCases()
Gets the list of cases defined for this switch.CtTry.getCatchers()
Gets the catchers of thistry
.CtComment.getCommentType()
Get the type of the commentCtConditional.getCondition()
Gets the condition expression.CtIf.getCondition()
Gets the boolean expression that represents theif
's condition.CtComment.getContent()
Get the content of the commentCtJavaDocTag.getContent()
Get the content of the atgCtNewArray.getDimensionExpressions()
Gets the expressions that define the array's dimensions.List<CtExpression<?>>
CtNewArray.getElements()
Gets the initialization expressions.CtConditional.getElseExpression()
Gets the "false" expression.<S extends CtStatement>
SCtIf.getElseStatement()
Gets the statement executed when the condition is false.CtAbstractInvocation.getExecutable()
Returns the invoked executable.CtExecutableReferenceExpression.getExecutable()
Gets the executable referenced by the expression.CtAssert.getExpression()
Gets the expression of the assertion if defined.CtFor.getExpression()
Gets the end-loop test expression.CtExpression<?>
CtForEach.getExpression()
Gets the iterated expression (an iterable of an array).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 thistry
(finally
part).CtFor.getForInit()
Gets the init statements.CtFor.getForUpdate()
Gets the update statements.CtArrayAccess.getIndexExpression()
Returns the expression that defines the index.CtBinaryOperator.getKind()
Gets the kind of this binary operator.CtOperatorAssignment.getKind()
Gets the operator kind.CtUnaryOperator.getKind()
Gets the kind of this operator.CtStatement.getLabel()
Gets the label of this statement if defined.CtExpression<?>
CtBinaryOperator.getLeftHandOperand()
Returns the left-hand operand.CtDo.getLoopingExpression()
Returns the looping test as a boolean expression.CtWhile.getLoopingExpression()
Gets the looping boolean test expression.CtExpression<?>
CtUnaryOperator.getOperand()
Gets the expression to which the operator is applied.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).CtJavaDocTag.getRealName()
The type of the tagList<CtResource<?>>
CtTryWithResource.getResources()
Gets the auto-closeable resources of thistry
.CtReturn.getReturnedExpression()
Gets the returned expression.CtExpression<?>
CtBinaryOperator.getRightHandOperand()
Returns the right-hand operand.CtAbstractSwitch.getSelector()
Gets the selector.CtStatementList.getStatements()
Returns the statement list.CtJavaDoc.getTags()
Get all the tag of the javadocCtTargetedExpression.getTarget()
Gets the target expression.CtLabelledFlowBreak.getTargetLabel()
Gets the label from which the control flow breaks (null if no label defined).CtConditional.getThenExpression()
Gets the "true" expression.<S extends CtStatement>
SCtIf.getThenStatement()
Gets the statement executed when the condition is true.CtExpression<? extends Throwable>
CtThrow.getThrownExpression()
Returns the thrown expression (must be a throwable).CtConstructorCall.getType()
CtInvocation.getType()
Return the type returned by the invocation.CtJavaDocTag.getType()
The type of the tagList<CtTypeReference<?>>
CtExpression.getTypeCasts()
Returns the type casts if any.CtLiteral.getValue()
Gets the actual value of the literal (statically known).CtAnnotationFieldAccess.getVariable()
CtFieldAccess.getVariable()
CtForEach.getVariable()
Gets the variable that references the currently iterated element.CtTypePattern.getVariable()
Returns the local variable declared by this type pattern.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 PropertyGetterModifier and TypeMethodDescription<A extends Annotation>
ACtElement.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.CtAnnotation.getAnnotationType()
Returns the annotation type of this annotation.CtClass.getAnonymousExecutables()
Returns the anonymous blocks of this class.CtElement.getComments()
The list of commentsCtClass.getConstructor(CtTypeReference<?>... parameterTypes)
Returns the constructor of the class that takes the given argument types.CtClass.getConstructors()
Returns the constructors of this class.CtCompilationUnit.getDeclaredModule()
Gets the declared module if the compilationUnit is "module-info.java"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.CtCompilationUnit.getDeclaredTypes()
Gets all the types declared in this compilation unit.CtAnnotationMethod.getDefaultExpression()
Gets the default expression assigned to the annotation method.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.CtModule.getExportedPackages()
CtModifiable.getExtendedModifiers()
CtField<?>
Gets a field from its name.CtType.getFields()
Returns the fields that are directly declared by this class or interface.CtFormalTypeDeclarer.getFormalCtTypeParameters()
Returns the formal type parameters of this generic element.CtProvidedService.getImplementationTypes()
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.CtType.getMethods()
Returns the methods that are directly declared by this class or interface.CtType.getMethodsAnnotatedWith(CtTypeReference<?>... annotationTypes)
Returns the methods that are directly declared by this class or interface and annotated with one of the given annotations.CtType.getMethodsByName(String name)
Returns the methods that are directly declared by this class or interface and that have the given name.CtModifiable.getModifiers()
Returns the modifiers of this element, excluding annotations.CtTypeInformation.getModifiers()
Gets modifiers of this type.CtModule.getModuleDirectives()
CtModuleRequirement.getModuleReference()
List<CtTypeReference<?>>
CtMultiTypedElement.getMultiTypes()
Gets all types of the element.<N extends CtType<?>>
NCtType.getNestedType(String name)
Gets a nested type from its name.CtType.getNestedTypes()
Returns the declarations of the nested classes and interfaces that are directly declared by this class or interface.CtModule.getOpenedPackages()
CtPackage.getPackage(String name)
Searches a child package by name.CtCompilationUnit.getPackageDeclaration()
CtPackageExport.getPackageReference()
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.CtElement.getPosition()
Gets the position of this element in input source filesCtModule.getProvidedServices()
CtRecord.getRecordComponents()
CtImport.getReference()
Returns the reference of the import.CtPackageDeclaration.getReference()
Returns the reference to the package.CtModule.getRequiredModules()
CtModuleRequirement.getRequiresModifiers()
CtModule.getRootPackage()
returns the root package of the unnamed module If there are several modules, it throws an exceptionCtProvidedService.getServiceType()
CtUsedService.getServiceType()
CtConstructor.getSimpleName()
Always returns "<init>".CtNamedElement.getSimpleName()
Returns the simple (unqualified) name of this element.CtType.getSimpleName()
Returns the simple (unqualified) name of this element.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.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<?>>
TFinds a top-level type by name.CtTypedElement.getType()
Gets this element's type.CtType.getTypeMembers()
Gets all type members of the type like fields, methods, anonymous block, etc.CtPackage.getTypes()
Returns the set of the top-level types in this package.CtModule.getUsedServices()
<T extends CtExpression>
TGets a value, as a CtExpression, for a given key without any conversion.CtCodeSnippet.getValue()
Gets the textual value of the code.CtAnnotation.getValues()
Returns this annotation's elements and their values.<T extends CtExpression>
TCtAnnotation.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 ofCtExecutable.getParameters()
). -
Uses of PropertyGetter in spoon.reflect.reference
Methods in spoon.reflect.reference with annotations of type PropertyGetterModifier and TypeMethodDescriptionList<CtTypeReference<?>>
CtActualTypeContainer.getActualTypeArguments()
Gets the type arguments.CtWildcardReference.getBoundingType()
A type parameter can have anextends
clause which declare one (CtTypeReference
or more (CtIntersectionTypeReference
references.List<CtTypeReference<?>>
CtIntersectionTypeReference.getBounds()
Gets the bounds of the intersection type.CtArrayTypeReference.getComponentType()
Gets the type of the elements contained in this array.CtExecutableReference.getDeclaringType()
Gets the reference to the type that declares this executable.CtFieldReference.getDeclaringType()
Gets the type in which the field is declared.CtTypeReference.getDeclaringType()
Gets the type that declares the referenced type.CtTypeReference.getPackage()
Gets the package of the referenced type.List<CtTypeReference<?>>
CtExecutableReference.getParameters()
Gets parameters of the executable.CtReference.getSimpleName()
Gets the simple name of referenced element.CtExecutableReference.getType()
For methods, gets the return type of the executable (may be null in noclasspath mode).CtVariableReference.getType()
Gets the type of the variable.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()
Returnstrue
if the bounds are inextends
clause.