Uses of Annotation Type
spoon.reflect.annotations.PropertySetter

Packages that use PropertySetter

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 PropertySetter in spoon.reflect.code

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

Modifier and Type	Method	Description
<T extends CtActualTypeContainer> T	CtConstructorCall.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)	Delegate to the executable reference of the constructor call.
<T extends CtActualTypeContainer> T	CtInvocation.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)	Delegate to the executable reference of the invocation.
<T extends CtActualTypeContainer> T	CtNewClass.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)	Delegate to the executable reference of the new class.
<C extends CtAbstractInvocation<T>> C	CtAbstractInvocation.addArgument(CtExpression<?> argument)	Adds an argument expression to the invocation.
<C extends CtAbstractInvocation<T>> C	CtAbstractInvocation.addArgumentAt(int position, CtExpression<?> argument)	Adds an argument expression to the invocation at the specified position.
<T extends CtAbstractSwitch<S>> T	CtAbstractSwitch.addCase(CtCase<? super S> c)	Adds a case;
<T extends CtAbstractSwitch<S>> T	CtAbstractSwitch.addCaseAt(int position, CtCase<? super S> c)	Adds a case at the specified position.
<T extends CtCase<S>> T	CtCase.addCaseExpression(CtExpression<S> caseExpression)	Adds case expression.
<T extends CtTry> T	CtTry.addCatcher(CtCatch catcher)	Adds a catch block.
CtTry	CtTry.addCatcherAt(int position, CtCatch catcher)	Adds a catch block at the specified position in the try statement.
<C extends CtNewArray<T>> C	CtNewArray.addDimensionExpression(CtExpression<Integer> dimension)	Adds a dimension expression.
<C extends CtNewArray<T>> C	CtNewArray.addElement(CtExpression<?> expression)	Adds an element.
<T extends CtFor> T	CtFor.addForInit(CtStatement statement)	Adds an init statement.
<T extends CtFor> T	CtFor.addForUpdate(CtStatement statement)	Adds an update statement.
<T extends CtTryWithResource> T	CtTryWithResource.addResource(CtResource<?> resource)	Adds a resource.
<T extends CtStatementList> T	CtStatementList.addStatement(int index, CtStatement statement)	Inserts the given statement at a specific position in the list of statements Shifts the statement currently at that position (if any) and any subsequent statements to the right (adds one to their indices).
<T extends CtStatementList> T	CtStatementList.addStatement(CtStatement statement)	Adds a statement at the end of the list.
<E extends CtJavaDoc> E	CtJavaDoc.addTag(int index, CtJavaDocTag tag)	Add a new tag at the index position
<E extends CtJavaDoc> E	CtJavaDoc.addTag(CtJavaDocTag tag)	Add a new tag at the end of the list
<C extends CtExpression<T>> C	CtExpression.addTypeCast(CtTypeReference<?> type)	Adds a type cast.
<T extends CtStatementList> T	CtStatementList.insertBegin(CtStatement statement)	Inserts the given statement at the beginning of the block.
<T extends CtStatementList> T	CtStatementList.insertBegin(CtStatementList statements)	Inserts the given statement list at the beginning of the block.
<T extends CtStatementList> T	CtStatementList.insertEnd(CtStatement statement)	Inserts the given statement at the end of the block.
<T extends CtStatementList> T	CtStatementList.insertEnd(CtStatementList statements)	Inserts the given statements at the end of the block.
void	CtAbstractInvocation.removeArgument(CtExpression<?> argument)	Removes an argument expression from the invocation.
boolean	CtAbstractSwitch.removeCase(CtCase<? super S> c)	Removes a case;
boolean	CtTry.removeCatcher(CtCatch catcher)	Removes a catch block.
boolean	CtNewArray.removeDimensionExpression(CtExpression<Integer> dimension)	Removes a dimension expression.
boolean	CtNewArray.removeElement(CtExpression<?> expression)	Removes an element.
boolean	CtFor.removeForInit(CtStatement statement)	Removes an init statement.
boolean	CtFor.removeForUpdate(CtStatement statement)	Removes an update statement.
boolean	CtTryWithResource.removeResource(CtResource<?> resource)	Removes a resource.
void	CtStatementList.removeStatement(CtStatement statement)	Removes a statement.
<E extends CtJavaDoc> E	CtJavaDoc.removeTag(int index)	Remove a tag from the index
<E extends CtJavaDoc> E	CtJavaDoc.removeTag(CtJavaDocTag tag)	Remove a specific tag
<C extends CtTypeAccess<A>> C	CtTypeAccess.setAccessedType(CtTypeReference<A> accessedType)	Set the accessed type.
<T extends CtActualTypeContainer> T	CtConstructorCall.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)	Delegate to the executable reference of the constructor call.
<T extends CtActualTypeContainer> T	CtInvocation.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)	Delegate to the executable reference of the invocation.
<T extends CtActualTypeContainer> T	CtNewClass.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)	Delegate to the executable reference of the new class.
<N extends CtNewClass> N	CtNewClass.setAnonymousClass(CtClass<?> anonymousClass)	Sets the created class.
<C extends CtAbstractInvocation<T>> C	CtAbstractInvocation.setArguments(List<CtExpression<?>> arguments)	Sets the invocation's arguments.
<A extends CtAssert<T>> A	CtAssert.setAssertExpression(CtExpression<Boolean> asserted)	Sets the assert expression.
<C extends CtAssignment<T, A>> C	CtAssignment.setAssigned(CtExpression<T> assigned)	Sets the assigned expression (left hand side - LHS).
<T extends CtRHSReceiver<A>> T	CtRHSReceiver.setAssignment(CtExpression<A> assignment)	Sets the right-hand side expression (RHS) of the "=" operator.
<C extends CtLiteral<T>> C	CtLiteral.setBase(LiteralBase base)	Sets the base of the numeric literal.
<T extends CtSynchronized> T	CtSynchronized.setBlock(CtBlock<?> block)	Sets the synchronized block.
<T extends CtBodyHolder> T	CtBodyHolder.setBody(CtStatement body)	Sets the body of this element.
<T extends CtCase<S>> T	CtCase.setCaseExpression(CtExpression<S> caseExpression)	Sets the case expression.
<T extends CtCase<S>> T	CtCase.setCaseExpressions(List<CtExpression<S>> caseExpressions)	Sets the case expressions.
<T extends CtCase<S>> T	CtCase.setCaseKind(CaseKind kind)	Sets the kind of this case - colon (:) or arrow (->) (Arrow syntax is available as a preview feature since Java 12)
<T extends CtAbstractSwitch<S>> T	CtAbstractSwitch.setCases(List<CtCase<? super S>> cases)	Sets the list of cases defined for this switch.
<T extends CtTry> T	CtTry.setCatchers(List<CtCatch> catchers)	Sets the catchers of this try.
<E extends CtComment> E	CtComment.setCommentType(CtComment.CommentType commentType)
<C extends CtConditional<T>> C	CtConditional.setCondition(CtExpression<Boolean> condition)	Sets the condition expression.
<T extends CtIf> T	CtIf.setCondition(CtExpression<Boolean> expression)	Sets the boolean expression that represents the if's condition.
<E extends CtComment> E	CtComment.setContent(String content)
<E extends CtJavaDocTag> E	CtJavaDocTag.setContent(String content)	Define the content of the tag
<C extends CtNewArray<T>> C	CtNewArray.setDimensionExpressions(List<CtExpression<Integer>> dimensions)	Sets the expressions that define the array's dimensions.
<C extends CtNewArray<T>> C	CtNewArray.setElements(List<CtExpression<?>> expression)	Sets the initialization expressions.
<C extends CtConditional<T>> C	CtConditional.setElseExpression(CtExpression<T> elseExpression)	Sets the "false" expression.
<T extends CtIf> T	CtIf.setElseStatement(CtStatement elseStatement)	Sets the statement executed when the condition is false.
<C extends CtAbstractInvocation<T>> C	CtAbstractInvocation.setExecutable(CtExecutableReference<T> executable)	Sets the invoked executable.
<C extends CtExecutableReferenceExpression<T, E>> C	CtExecutableReferenceExpression.setExecutable(CtExecutableReference<T> executable)	Sets the executable will be referenced by the expression.
<A extends CtAssert<T>> A	CtAssert.setExpression(CtExpression<T> expression)	Sets the expression of the assertion.
<T extends CtFor> T	CtFor.setExpression(CtExpression<Boolean> expression)	Sets the end-loop test expression.
<T extends CtForEach> T	CtForEach.setExpression(CtExpression<?> expression)	Sets the iterated expression (an iterable of an array).
<C extends CtLambda<T>> C	CtLambda.setExpression(CtExpression<T> expression)	Sets the expression in the body of the lambda.
<T extends CtSynchronized> T	CtSynchronized.setExpression(CtExpression<?> expression)	Sets the expression that defines the monitored.
<T extends CtYieldStatement> T	CtYieldStatement.setExpression(CtExpression<?> expression)	Gets the expression of the yield statement.
<T extends CtTry> T	CtTry.setFinalizer(CtBlock<?> finalizer)	Sets the finalizer block of this try ( finally part).
<T extends CtFor> T	CtFor.setForInit(List<CtStatement> forInit)	Sets the init statements.
<T extends CtFor> T	CtFor.setForUpdate(List<CtStatement> forUpdate)	Sets the update statements.
<C extends CtArrayAccess<T, E>> C	CtArrayAccess.setIndexExpression(CtExpression<Integer> expression)	Sets the expression that defines the index.
<U extends CtLocalVariable<T>> U	CtLocalVariable.setInferred(boolean inferred)	Set true if the variable must be inferred.
<C extends CtBinaryOperator<T>> C	CtBinaryOperator.setKind(BinaryOperatorKind kind)	Sets the kind of this binary operator.
<C extends CtOperatorAssignment<T, A>> C	CtOperatorAssignment.setKind(BinaryOperatorKind kind)	Sets the operator kind.
<C extends CtUnaryOperator> C	CtUnaryOperator.setKind(UnaryOperatorKind kind)	Sets the kind of this operator.
<T extends CtStatement> T	CtStatement.setLabel(String label)	Sets the label of this statement.
<C extends CtBinaryOperator<T>> C	CtBinaryOperator.setLeftHandOperand(CtExpression<?> expression)	Sets the left-hand operand.
<T extends CtDo> T	CtDo.setLoopingExpression(CtExpression<Boolean> expression)	Sets the looping test as a boolean expression.
<T extends CtWhile> T	CtWhile.setLoopingExpression(CtExpression<Boolean> expression)	Sets the looping boolean test expression.
<C extends CtUnaryOperator> C	CtUnaryOperator.setOperand(CtExpression<?> expression)	Sets the expression to which the operator is applied.
<E extends CtJavaDocTag> E	CtJavaDocTag.setParam(String param)	Define a parameter
<T extends CtCatch> T	CtCatch.setParameter(CtCatchVariable<? extends Throwable> parameter)	Sets the catch's parameter (a throwable).
<E extends CtJavaDocTag> E	CtJavaDocTag.setRealName(String realName)	Define the real name of tag type
<T extends CtTryWithResource> T	CtTryWithResource.setResources(List<? extends CtResource<?>> resources)	Sets the auto-closeable resources of this try.
<T extends CtReturn<R>> T	CtReturn.setReturnedExpression(CtExpression<R> returnedExpression)	Sets the returned expression.
<C extends CtBinaryOperator<T>> C	CtBinaryOperator.setRightHandOperand(CtExpression<?> expression)	Sets the right-hand operand.
<T extends CtAbstractSwitch<S>> T	CtAbstractSwitch.setSelector(CtExpression<S> selector)	Sets the selector.
<T extends CtStatementList> T	CtStatementList.setStatements(List<CtStatement> statements)	Sets the statement list.
<E extends CtJavaDoc> E	CtJavaDoc.setTags(List<CtJavaDocTag> tags)	Define the list of tags
<C extends CtTargetedExpression<T, E>> C	CtTargetedExpression.setTarget(E target)	Sets the target expression.
<T extends CtLabelledFlowBreak> T	CtLabelledFlowBreak.setTargetLabel(String targetLabel)	Sets the label from which the control flow breaks (null if no label defined).
<C extends CtConditional<T>> C	CtConditional.setThenExpression(CtExpression<T> thenExpression)	Sets the "true" expression.
<T extends CtIf> T	CtIf.setThenStatement(CtStatement thenStatement)	Sets the statement executed when the condition is true.
<T extends CtThrow> T	CtThrow.setThrownExpression(CtExpression<? extends Throwable> thrownExpression)	Sets the thrown expression (must be a throwable).
<E extends CtJavaDocTag> E	CtJavaDocTag.setType(String type)	Define the type of the tag
<E extends CtJavaDocTag> E	CtJavaDocTag.setType(CtJavaDocTag.TagType type)	Define the type of the tag
<C extends CtExpression<T>> C	CtExpression.setTypeCasts(List<CtTypeReference<?>> types)	Sets the type casts.
<C extends CtLiteral<T>> C	CtLiteral.setValue(T value)	Sets the actual value of the literal.
<T extends CtForEach> T	CtForEach.setVariable(CtLocalVariable<?> variable)	Sets the variable that references the currently iterated element.
CtTypePattern	CtTypePattern.setVariable(CtLocalVariable<?> variable)	Sets the local variable for this type pattern.
<C extends CtVariableAccess<T>> C	CtVariableAccess.setVariable(CtVariableReference<T> variable)	Sets the reference to the accessed variable.

Uses of PropertySetter in spoon.reflect.declaration

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

Modifier and Type	Method	Description
<E extends CtElement> E	CtElement.addAnnotation(CtAnnotation<? extends Annotation> annotation)	Add an annotation for this element
<C extends CtClass<T>> C	CtClass.addAnonymousExecutable(CtAnonymousExecutable e)	Add an anonymous block to this class.
<E extends CtElement> E	CtElement.addComment(CtComment comment)	Add a comment to the current element element.addComment(element.getFactory().Code().createComment("comment", CtComment.CommentType.INLINE)
<C extends CtClass<T>> C	CtClass.addConstructor(CtConstructor<T> constructor)	Adds a constructor to this class.
CtCompilationUnit	CtCompilationUnit.addDeclaredTypeReference(CtTypeReference<?> type)	Add a type reference to the list of declared types
<C extends CtEnum<T>> C	CtEnum.addEnumValue(CtEnumValue<?> enumValue)	Adds an enum value.
<T extends CtModule> T	CtModule.addExportedPackage(CtPackageExport exportedPackage)
<F, C extends CtType<T>> C	CtType.addField(int index, CtField<F> field)	add a field at a given position.
<F, C extends CtType<T>> C	CtType.addField(CtField<F> field)	add a field at the end of the field list.
<F, C extends CtType<T>> C	CtType.addFieldAtTop(CtField<F> field)	Adds a field at the top of the type (before static block).
<T extends CtFormalTypeDeclarer> T	CtFormalTypeDeclarer.addFormalCtTypeParameter(CtTypeParameter formalTypeParameter)	Add a type parameter to this generic element.
<T extends CtFormalTypeDeclarer> T	CtFormalTypeDeclarer.addFormalCtTypeParameterAt(int position, CtTypeParameter formalTypeParameter)	Add a type parameter at a specific position.
<T extends CtProvidedService> T	CtProvidedService.addImplementationType(CtTypeReference usedType)
<M, C extends CtType<T>> C	CtType.addMethod(CtMethod<M> method)	Adds a method to this type.
<T extends CtModifiable> T	CtModifiable.addModifier(ModifierKind modifier)	add a modifier
<T extends CtModule> T	CtModule.addModuleDirective(CtModuleDirective moduleDirective)
<T extends CtModule> T	CtModule.addModuleDirectiveAt(int position, CtModuleDirective moduleDirective)
<T extends CtMultiTypedElement> T	CtMultiTypedElement.addMultiType(CtTypeReference<?> ref)	Adds a type for the element.
<N, C extends CtType<T>> C	CtType.addNestedType(CtType<N> nestedType)	Add a nested type.
<T extends CtModule> T	CtModule.addOpenedPackage(CtPackageExport openedPackage)
<T extends CtPackage> T	CtPackage.addPackage(CtPackage pack)	add a subpackage
<T extends CtExecutable<R>> T	CtExecutable.addParameter(CtParameter<?> parameter)	Add a parameter for this executable
<T extends CtExecutable<R>> T	CtExecutable.addParameterAt(int position, CtParameter<?> parameter)	Add a parameter at a specific position in the executable.
CtSealable	CtSealable.addPermittedType(CtTypeReference<?> type)	Adds a permitted type to this type.
<T extends CtModule> T	CtModule.addProvidedService(CtProvidedService providedService)
CtRecord	CtRecord.addRecordComponent(CtRecordComponent component)
<T extends CtModule> T	CtModule.addRequiredModule(CtModuleRequirement requiredModule)
<S, C extends CtType<T>> C	CtType.addSuperInterface(CtTypeReference<S> interfac)
<T extends CtPackageExport> T	CtPackageExport.addTargetExport(CtModuleReference targetExport)
<T extends CtExecutable<R>> T	CtExecutable.addThrownType(CtTypeReference<? extends Throwable> throwType)	add a thrown type.
<T extends CtPackage> T	CtPackage.addType(CtType<?> type)	Adds a type to this package.
<C extends CtType<T>> C	CtType.addTypeMember(CtTypeMember member)	Adds a type member at the end of all type member of the type.
<C extends CtType<T>> C	CtType.addTypeMemberAt(int position, CtTypeMember member)	Adds a type member at a given position.
<T extends CtModule> T	CtModule.addUsedService(CtUsedService usedService)
<T extends CtAnnotation<A>> T	CtAnnotation.addValue(String elementName, Object value)	Adds a new key-value pair for this annotation
<T extends CtAnnotation<A>> T	CtAnnotation.addValue(String elementName, CtFieldAccess<?> value)	Adds a new key-field access pair for this annotation.
<T extends CtAnnotation<A>> T	CtAnnotation.addValue(String elementName, CtLiteral<?> value)	Adds a new key-literal pair for this annotation.
<T extends CtAnnotation<A>> T	CtAnnotation.addValue(String elementName, CtNewArray<? extends CtExpression> value)	Adds a new key-array pair for this annotation.
<T extends CtAnnotation<A>> T	CtAnnotation.addValue(String elementName, CtAnnotation<?> value)	Adds a new key-annotation pair for this annotation.
boolean	CtElement.removeAnnotation(CtAnnotation<? extends Annotation> annotation)	Remove an annotation for this element
boolean	CtClass.removeAnonymousExecutable(CtAnonymousExecutable e)	Remove an anonymous block to this class.
<E extends CtElement> E	CtElement.removeComment(CtComment comment)	Remove a comment
void	CtClass.removeConstructor(CtConstructor<T> constructor)	Removes a constructor from this class.
boolean	CtEnum.removeEnumValue(CtEnumValue<?> enumValue)	Removes en enum value.
<T extends CtModule> T	CtModule.removeExportedPackage(CtPackageExport exportedPackage)
<F> boolean	CtType.removeField(CtField<F> field)	remove a Field
boolean	CtFormalTypeDeclarer.removeFormalCtTypeParameter(CtTypeParameter formalTypeParameter)	Removes a type parameters from this generic element.
<M> boolean	CtType.removeMethod(CtMethod<M> method)	Removes a method from this type.
<T extends CtModifiable> T	CtModifiable.removeModifier(ModifierKind modifier)	remove a modifier
<T extends CtModule> T	CtModule.removeModuleDirective(CtModuleDirective moduleDirective)
boolean	CtMultiTypedElement.removeMultiType(CtTypeReference<?> ref)	Removes a type for the element.
<N> boolean	CtType.removeNestedType(CtType<N> nestedType)	Remove a nested type.
<T extends CtModule> T	CtModule.removeOpenedPackage(CtPackageExport openedPackage)
boolean	CtPackage.removePackage(CtPackage pack)	remove a subpackage
CtSealable	CtSealable.removePermittedType(CtTypeReference<?> type)	Adds a permitted type to this type.
<T extends CtModule> T	CtModule.removeProvidedService(CtProvidedService providedService)
CtRecord	CtRecord.removeRecordComponent(CtRecordComponent component)
<T extends CtModule> T	CtModule.removeRequiredModule(CtModuleRequirement requiredModule)
<S> boolean	CtType.removeSuperInterface(CtTypeReference<S> interfac)
boolean	CtExecutable.removeThrownType(CtTypeReference<? extends Throwable> throwType)	remove a thrown type.
void	CtPackage.removeType(CtType<?> type)	Removes a type from this package.
boolean	CtType.removeTypeMember(CtTypeMember member)	Removes the type member.
<T extends CtModule> T	CtModule.removeUsedService(CtUsedService usedService)
<E extends CtElement> E	CtElement.setAnnotations(List<CtAnnotation<? extends Annotation>> annotation)	Sets the annotations for this element.
<T extends CtAnnotation<A>> T	CtAnnotation.setAnnotationType(CtTypeReference<? extends Annotation> type)	Sets the annotation's type.
<C extends CtClass<T>> C	CtClass.setAnonymousExecutables(List<CtAnonymousExecutable> e)	Sets the anonymous blocks of this class.
<E extends CtElement> E	CtElement.setComments(List<CtComment> comments)	Set the comment list
void	CtConstructor.setCompactConstructor(boolean compactConstructor)	Marks the constructor as a compact constructor.
<C extends CtClass<T>> C	CtClass.setConstructors(Set<CtConstructor<T>> constructors)	Sets the constructors for this class.
CtCompilationUnit	CtCompilationUnit.setDeclaredModuleReference(CtModuleReference module)	Sets the declared module reference if the compilationUnit is "module-info.java"
CtCompilationUnit	CtCompilationUnit.setDeclaredTypeReferences(List<CtTypeReference<?>> types)	Sets the references to types declared in this compilation unit.
<C extends CtAnnotationMethod<T>> C	CtAnnotationMethod.setDefaultExpression(CtExpression<T> assignedExpression)	Sets the default expression assigned to the annotation method.
<C extends CtVariable<T>> C	CtVariable.setDefaultExpression(CtExpression<T> assignedExpression)	Sets the initialization expression assigned to the variable, when declared.
<C extends CtMethod<T>> C	CtMethod.setDefaultMethod(boolean defaultMethod)	Sets the default value state of a method.
<T extends CtAnnotation<A>> T	CtAnnotation.setElementValues(Map<String,Object> values)	Set's this annotation's element names and their values.
<C extends CtEnum<T>> C	CtEnum.setEnumValues(List<CtEnumValue<?>> enumValues)	Sets all enum values of the enum.
<T extends CtModule> T	CtModule.setExportedPackages(List<CtPackageExport> exportedPackages)
<C extends CtType<T>> C	CtType.setFields(List<CtField<?>> fields)	Sets all fields in the type.
<T extends CtFormalTypeDeclarer> T	CtFormalTypeDeclarer.setFormalCtTypeParameters(List<CtTypeParameter> formalTypeParameters)	Sets the type parameters of this generic element.
<T extends CtProvidedService> T	CtProvidedService.setImplementationTypes(List<CtTypeReference> usedTypes)
<E extends CtElement> E	CtElement.setImplicit(boolean b)	Sets this element to be implicit.
CtCompilationUnit	CtCompilationUnit.setImports(Collection<CtImport> imports)	Set the imports of this CU WARNING: This method is tagged as experimental, as its signature and/or usage might change in future release.
<U extends CtParameter<T>> U	CtParameter.setInferred(boolean inferred)	Set to true if this parameter is a lambda parameter with type defined using the `var` keyword.
<T extends CtModule> T	CtModule.setIsOpenModule(boolean openModule)
<C extends CtType<T>> C	CtType.setMethods(Set<CtMethod<?>> methods)	Sets the methods of this type.
<T extends CtModifiable> T	CtModifiable.setModifiers(Set<ModifierKind> modifiers)	Sets the modifiers.
<T extends CtModule> T	CtModule.setModuleDirectives(List<CtModuleDirective> moduleDirectives)
<T extends CtModuleRequirement> T	CtModuleRequirement.setModuleReference(CtModuleReference moduleReference)
<T extends CtMultiTypedElement> T	CtMultiTypedElement.setMultiTypes(List<CtTypeReference<?>> types)	Adds a type for the element.
<C extends CtType<T>> C	CtType.setNestedTypes(Set<CtType<?>> nestedTypes)	Sets all nested types.
<T extends CtPackageExport> T	CtPackageExport.setOpenedPackage(boolean openedPackage)
<T extends CtModule> T	CtModule.setOpenedPackages(List<CtPackageExport> openedPackages)
CtCompilationUnit	CtCompilationUnit.setPackageDeclaration(CtPackageDeclaration packageDeclaration)	Sets the package declaration
<T extends CtPackageExport> T	CtPackageExport.setPackageReference(CtPackageReference packageReference)
<T extends CtPackage> T	CtPackage.setPackages(Set<CtPackage> pack)	Sets the children defined in this package
<T extends CtExecutable<R>> T	CtExecutable.setParameters(List<CtParameter<?>> parameters)	Sets the parameters.
CtSealable	CtSealable.setPermittedTypes(Collection<CtTypeReference<?>> permittedTypes)	Sets the permitted types for this type.
<E extends CtElement> E	CtElement.setPosition(SourcePosition position)	Sets the position in the Java source file.
<T extends CtModule> T	CtModule.setProvidedServices(List<CtProvidedService> providedServices)
CtRecord	CtRecord.setRecordComponents(Set<CtRecordComponent> components)
<T extends CtImport> T	CtImport.setReference(CtReference reference)	Sets the reference of the import.
CtPackageDeclaration	CtPackageDeclaration.setReference(CtPackageReference reference)	Sets the reference to the package.
<T extends CtModule> T	CtModule.setRequiredModules(List<CtModuleRequirement> requiredModules)
<T extends CtModuleRequirement> T	CtModuleRequirement.setRequiresModifiers(Set<CtModuleRequirement.RequiresModifier> requiresModifiers)
<T extends CtModule> T	CtModule.setRootPackage(CtPackage rootPackage)
<T extends CtProvidedService> T	CtProvidedService.setServiceType(CtTypeReference providingType)
<T extends CtUsedService> T	CtUsedService.setServiceType(CtTypeReference providingType)
<E extends CtShadowable> E	CtShadowable.setShadow(boolean isShadow)	Marks an element as shadow.
<T extends CtNamedElement> T	CtNamedElement.setSimpleName(String simpleName)	Sets the simple (unqualified) name of this element.
<C extends CtType<T>> C	CtType.setSuperclass(CtTypeReference<?> superClass)	Sets the superclass type.
<C extends CtType<T>> C	CtType.setSuperInterfaces(Set<CtTypeReference<?>> interfaces)	Sets the super interfaces of this type.
<T extends CtPackageExport> T	CtPackageExport.setTargetExport(List<CtModuleReference> targetExport)
<T extends CtExecutable<R>> T	CtExecutable.setThrownTypes(Set<CtTypeReference<? extends Throwable>> thrownTypes)	Sets the thrown types.
<C extends CtTypedElement> C	CtTypedElement.setType(CtTypeReference type)	Sets this element's type.
<C extends CtType<T>> C	CtType.setTypeMembers(List<CtTypeMember> members)	Removes all types members with these new members.
<T extends CtPackage> T	CtPackage.setTypes(Set<CtType<?>> types)	Sets the types defined in the package.
<T extends CtModule> T	CtModule.setUsedServices(List<CtUsedService> usedServices)
<C extends CtCodeSnippet> C	CtCodeSnippet.setValue(String value)	Sets the textual value of the code.
<T extends CtAnnotation<A>> T	CtAnnotation.setValues(Map<String,CtExpression> values)	Set's this annotation's element names and their values.
<C extends CtParameter<T>> C	CtParameter.setVarArgs(boolean varArgs)	Sets this parameter to have varargs.
<T extends CtModifiable> T	CtModifiable.setVisibility(ModifierKind visibility)	Sets the visibility of this modifiable element (replaces old visibility).

Uses of PropertySetter in spoon.reflect.reference

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

Modifier and Type	Method	Description
<C extends CtIntersectionTypeReference> C	CtIntersectionTypeReference.addBound(CtTypeReference<?> bound)	Adds a bound.
boolean	CtIntersectionTypeReference.removeBound(CtTypeReference<?> bound)	Removes a bound.
<T extends CtActualTypeContainer> T	CtActualTypeContainer.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)	Sets the type arguments.
<T extends CtWildcardReference> T	CtWildcardReference.setBoundingType(CtTypeReference<?> superType)	Sets the extends clause of the type parameter.
<C extends CtIntersectionTypeReference> C	CtIntersectionTypeReference.setBounds(List<CtTypeReference<?>> bounds)	Sets the bounds of the intersection type.
<C extends CtArrayTypeReference<T>> C	CtArrayTypeReference.setComponentType(CtTypeReference<?> componentType)	Sets the type of the elements contained in this array.
<C extends CtExecutableReference<T>> C	CtExecutableReference.setDeclaringType(CtTypeReference<?> declaringType)	Sets the declaring type.
<C extends CtFieldReference<T>> C	CtFieldReference.setDeclaringType(CtTypeReference<?> declaringType)	Sets the type in which the field is declared.
<C extends CtTypeReference<T>> C	CtTypeReference.setDeclaringType(CtTypeReference<?> type)	Sets the reference to the declaring type.
<C extends CtFieldReference<T>> C	CtFieldReference.setFinal(boolean b)	Forces a reference to a final element.
<C extends CtTypeReference<T>> C	CtTypeReference.setPackage(CtPackageReference pack)	Sets the reference to the declaring package.
<C extends CtExecutableReference<T>> C	CtExecutableReference.setParameters(List<CtTypeReference<?>> parameters)	Sets parameters of the executable.
<T extends CtReference> T	CtReference.setSimpleName(String simpleName)	Sets the name of referenced element.
<C extends CtExecutableReference<T>> C	CtExecutableReference.setStatic(boolean b)	Sets this executable reference to be static or not.
<C extends CtFieldReference<T>> C	CtFieldReference.setStatic(boolean b)	Forces a reference to a static element.
<C extends CtExecutableReference<T>> C	CtExecutableReference.setType(CtTypeReference type)	Sets the type of the variable.
<C extends CtVariableReference<T>> C	CtVariableReference.setType(CtTypeReference type)	Sets the type of the variable.
CtTypeMemberWildcardImportReference	CtTypeMemberWildcardImportReference.setTypeReference(CtTypeReference<?> typeReference)
<T extends CtWildcardReference> T	CtWildcardReference.setUpper(boolean upper)	Set to true to write extends clause for bounds types.