Uses of Annotation Type
spoon.support.UnsettableProperty

Packages that use UnsettableProperty

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

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

Modifier and Type	Method	Description
<C extends CtExpression<Void>> C	CtTypePattern.addTypeCast(CtTypeReference<?> type)
List<CtTypeReference<?>>	CtTypePattern.getTypeCasts()
<U extends CtRHSReceiver<T>> U	CtLocalVariable.setAssignment(CtExpression<T> assignment)
<C extends CtVariable<T>> C	CtCatchVariable.setDefaultExpression(CtExpression<T> assignedExpression)
<T1 extends CtExecutable<T>> T1	CtLambda.setThrownTypes(Set<CtTypeReference<? extends Throwable>> thrownTypes)
<C extends CtTypedElement> C	CtCatchVariable.setType(CtTypeReference type)
<C extends CtTypedElement> C	CtTypeAccess.setType(CtTypeReference type)
<C extends CtExpression<Void>> C	CtTypePattern.setTypeCasts(List<CtTypeReference<?>> types)

Uses of UnsettableProperty in spoon.reflect.declaration

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

Modifier and Type	Method	Description
<F, C extends CtType<Object>> C	CtTypeParameter.addFieldAtTop(CtField<F> field)
<M, C extends CtType<Object>> C	CtTypeParameter.addMethod(CtMethod<M> method)
<N, C extends CtType<Object>> C	CtTypeParameter.addNestedType(CtType<N> nestedType)
<T extends CtExecutable<Void>> T	CtAnonymousExecutable.addParameter(CtParameter<?> parameter)
<T extends CtExecutable<Void>> T	CtAnonymousExecutable.addParameterAt(int position, CtParameter<?> parameter)
CtEnum<T>	CtEnum.addPermittedType(CtTypeReference<?> type)
CtRecord	CtRecord.addPermittedType(CtTypeReference<?> type)
<S, C extends CtType<Object>> C	CtTypeParameter.addSuperInterface(CtTypeReference<S> interfac)
<T extends CtExecutable<Void>> T	CtAnonymousExecutable.addThrownType(CtTypeReference<? extends Throwable> throwType)
String	CtInterface.getLabel()
CtEnum<T>	CtEnum.removePermittedType(CtTypeReference<?> type)
CtRecord	CtRecord.removePermittedType(CtTypeReference<?> type)
<U extends CtRHSReceiver<T>> U	CtEnumValue.setAssignment(CtExpression<T> assignment)
<U extends CtRHSReceiver<T>> U	CtField.setAssignment(CtExpression<T> assignment)
<T1 extends CtBodyHolder> T1	CtAnnotationMethod.setBody(CtStatement body)
<C extends CtVariable<T>> C	CtParameter.setDefaultExpression(CtExpression<T> assignedExpression)
<C extends CtType<Object>> C	CtTypeParameter.setFields(List<CtField<?>> fields)
<T extends CtFormalTypeDeclarer> T	CtAnnotationMethod.setFormalCtTypeParameters(List<CtTypeParameter> formalTypeParameters)
<T extends CtFormalTypeDeclarer> T	CtAnnotationType.setFormalCtTypeParameters(List<CtTypeParameter> formalTypeParameters)
<T extends CtFormalTypeDeclarer> T	CtEnum.setFormalCtTypeParameters(List<CtTypeParameter> formalTypeParameters)
<T extends CtFormalTypeDeclarer> T	CtTypeParameter.setFormalCtTypeParameters(List<CtTypeParameter> formalTypeParameters)
<C extends CtStatement> C	CtClass.setLabel(String label)
<C extends CtType<Object>> C	CtTypeParameter.setMethods(Set<CtMethod<?>> methods)
<T extends CtModifiable> T	CtTypeParameter.setModifiers(Set<ModifierKind> modifiers)
<C extends CtType<Object>> C	CtTypeParameter.setNestedTypes(Set<CtType<?>> nestedTypes)
<T1 extends CtExecutable<T>> T1	CtAnnotationMethod.setParameters(List<CtParameter<?>> parameters)
<T extends CtExecutable<Void>> T	CtAnonymousExecutable.setParameters(List<CtParameter<?>> parameters)
<E extends CtElement> E	CtCompilationUnit.setParent(CtElement parent)
CtEnum<T>	CtEnum.setPermittedTypes(Collection<CtTypeReference<?>> permittedTypes)
CtRecord	CtRecord.setPermittedTypes(Collection<CtTypeReference<?>> permittedTypes)
<E extends CtElement> E	CtCompilationUnit.setPosition(SourcePosition position)
<C extends CtNamedElement> C	CtAnonymousExecutable.setSimpleName(String simpleName)
<C extends CtNamedElement> C	CtConstructor.setSimpleName(String simpleName)
<C extends CtType<T>> C	CtAnnotationType.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<T>> C	CtEnum.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<T>> C	CtInterface.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<Object>> C	CtRecord.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<T>> C	CtAnnotationType.setSuperInterfaces(Set<CtTypeReference<?>> interfaces)
<C extends CtType<Object>> C	CtTypeParameter.setSuperInterfaces(Set<CtTypeReference<?>> interfaces)
<T1 extends CtExecutable<T>> T1	CtAnnotationMethod.setThrownTypes(Set<CtTypeReference<? extends Throwable>> thrownTypes)
<T extends CtExecutable<Void>> T	CtAnonymousExecutable.setThrownTypes(Set<CtTypeReference<? extends Throwable>> thrownTypes)
<C extends CtTypedElement> C	CtAnonymousExecutable.setType(CtTypeReference type)
<C extends CtTypedElement> C	CtConstructor.setType(CtTypeReference type)
<C extends CtExpression<A>> C	CtAnnotation.setTypeCasts(List<CtTypeReference<?>> types)
<C extends CtType<Object>> C	CtTypeParameter.setTypeMembers(List<CtTypeMember> members)

Uses of UnsettableProperty in spoon.reflect.reference

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

Modifier and Type	Method	Description
<E extends CtElement> E	CtTypeMemberWildcardImportReference.addAnnotation(CtAnnotation<? extends Annotation> annotation)
boolean	CtTypeMemberWildcardImportReference.removeAnnotation(CtAnnotation<? extends Annotation> annotation)
<T extends CtActualTypeContainer> T	CtTypeParameterReference.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)
<E extends CtElement> E	CtTypeMemberWildcardImportReference.setAnnotations(List<CtAnnotation<? extends Annotation>> annotation)
<E extends CtElement> E	CtUnboundVariableReference.setAnnotations(List<CtAnnotation<? extends Annotation>> annotation)
<E extends CtElement> E	CtReference.setComments(List<CtComment> comments)	comments are not possible for references
<E extends CtElement> E	CtTypeMemberWildcardImportReference.setImplicit(boolean b)
<T extends CtReference> T	CtArrayTypeReference.setSimpleName(String simpleName)	The simple name of an ArrayTypeReference is unsettable as it's retrieved from its component type.
<T extends CtReference> T	CtTypeMemberWildcardImportReference.setSimpleName(String simpleName)
<C extends CtReference> C	CtWildcardReference.setSimpleName(String simpleName)

Uses of UnsettableProperty in spoon.support.reflect.code

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

Modifier and Type	Method	Description
<C extends CtRHSReceiver<T>> C	CtLocalVariableImpl.setAssignment(CtExpression<T> assignment)
<C extends CtVariable<T>> C	CtCatchVariableImpl.setDefaultExpression(CtExpression<T> defaultExpression)
<C extends CtExecutable<T>> C	CtLambdaImpl.setThrownTypes(Set<CtTypeReference<? extends Throwable>> thrownTypes)
<C extends CtTypedElement> C	CtTypeAccessImpl.setType(CtTypeReference type)

Uses of UnsettableProperty in spoon.support.reflect.declaration

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

Modifier and Type	Method	Description
<F, C extends CtType<Object>> C	CtTypeParameterImpl.addField(int index, CtField<F> field)
<F, C extends CtType<Object>> C	CtTypeParameterImpl.addField(CtField<F> field)
<F, C extends CtType<Object>> C	CtTypeParameterImpl.addFieldAtTop(CtField<F> field)
<M, C extends CtType<Object>> C	CtTypeParameterImpl.addMethod(CtMethod<M> method)
<C extends CtModifiable> C	CtTypeParameterImpl.addModifier(ModifierKind modifier)
<N, C extends CtType<Object>> C	CtTypeParameterImpl.addNestedType(CtType<N> nestedType)
CtExecutable	CtAnonymousExecutableImpl.addParameter(CtParameter parameter)
CtExecutable	CtAnonymousExecutableImpl.addParameterAt(int position, CtParameter parameter)
CtEnum<T>	CtEnumImpl.addPermittedType(CtTypeReference<?> type)
CtRecord	CtRecordImpl.addPermittedType(CtTypeReference<?> type)
<S, C extends CtType<Object>> C	CtTypeParameterImpl.addSuperInterface(CtTypeReference<S> interfac)
CtExecutable	CtAnonymousExecutableImpl.addThrownType(CtTypeReference throwType)
<M> boolean	CtTypeParameterImpl.removeMethod(CtMethod<M> method)
<C extends CtModifiable> C	CtTypeParameterImpl.removeModifier(ModifierKind modifier)
<N> boolean	CtTypeParameterImpl.removeNestedType(CtType<N> nestedType)
boolean	CtAnonymousExecutableImpl.removeParameter(CtParameter parameter)
CtEnum<T>	CtEnumImpl.removePermittedType(CtTypeReference<?> type)
CtRecord	CtRecordImpl.removePermittedType(CtTypeReference<?> type)
<S> boolean	CtTypeParameterImpl.removeSuperInterface(CtTypeReference<S> interfac)
boolean	CtAnonymousExecutableImpl.removeThrownType(CtTypeReference throwType)
<T extends CtBodyHolder> T	CtAnnotationMethodImpl.setBody(CtStatement statement)
<C extends CtVariable<T>> C	CtParameterImpl.setDefaultExpression(CtExpression<T> defaultExpression)
<C extends CtType<Object>> C	CtTypeParameterImpl.setFields(List<CtField<?>> fields)
<C extends CtFormalTypeDeclarer> C	CtAnnotationMethodImpl.setFormalCtTypeParameters(List<CtTypeParameter> formalTypeParameters)
<C extends CtFormalTypeDeclarer> C	CtAnnotationTypeImpl.setFormalCtTypeParameters(List<CtTypeParameter> formalTypeParameters)
<C extends CtFormalTypeDeclarer> C	CtEnumImpl.setFormalCtTypeParameters(List<CtTypeParameter> formalTypeParameters)
<C extends CtFormalTypeDeclarer> C	CtTypeParameterImpl.setFormalCtTypeParameters(List<CtTypeParameter> formalTypeParameters)
<C extends CtStatement> C	CtClassImpl.setLabel(String label)
<C extends CtStatement> C	CtInterfaceImpl.setLabel(String label)
<C extends CtType<Object>> C	CtTypeParameterImpl.setMethods(Set<CtMethod<?>> methods)
<C extends CtModifiable> C	CtTypeParameterImpl.setModifiers(Set<ModifierKind> modifiers)
<C extends CtType<Object>> C	CtTypeParameterImpl.setNestedTypes(Set<CtType<?>> nestedTypes)
<U extends CtExecutable<T>> U	CtAnnotationMethodImpl.setParameters(List<CtParameter<?>> parameters)
CtExecutable	CtAnonymousExecutableImpl.setParameters(List list)
<E extends CtElement> E	CtCompilationUnitImpl.setParent(CtElement parent)
CtEnum<T>	CtEnumImpl.setPermittedTypes(Collection<CtTypeReference<?>> permittedTypes)
CtRecord	CtRecordImpl.setPermittedTypes(Collection<CtTypeReference<?>> permittedTypes)
<E extends CtElement> E	CtCompilationUnitImpl.setPosition(SourcePosition position)
<T extends CtNamedElement> T	CtAnonymousExecutableImpl.setSimpleName(String simpleName)
<C extends CtNamedElement> C	CtConstructorImpl.setSimpleName(String simpleName)
<C extends CtType<T>> C	CtAnnotationTypeImpl.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<T>> C	CtEnumImpl.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<T>> C	CtInterfaceImpl.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<Object>> C	CtRecordImpl.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<T>> C	CtTypeImpl.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<T>> C	CtAnnotationTypeImpl.setSuperInterfaces(Set<CtTypeReference<?>> interfaces)
<C extends CtType<Object>> C	CtTypeParameterImpl.setSuperInterfaces(Set<CtTypeReference<?>> interfaces)
<U extends CtExecutable<T>> U	CtAnnotationMethodImpl.setThrownTypes(Set<CtTypeReference<? extends Throwable>> thrownTypes)
CtExecutable	CtAnonymousExecutableImpl.setThrownTypes(Set thrownTypes)
<C extends CtTypedElement> C	CtAnonymousExecutableImpl.setType(CtTypeReference type)
<C extends CtTypedElement> C	CtConstructorImpl.setType(CtTypeReference type)
<C extends CtExpression<A>> C	CtAnnotationImpl.setTypeCasts(List<CtTypeReference<?>> casts)
<C extends CtType<Object>> C	CtTypeParameterImpl.setTypeMembers(List<CtTypeMember> members)
<C extends CtModifiable> C	CtTypeParameterImpl.setVisibility(ModifierKind visibility)

Uses of UnsettableProperty in spoon.support.reflect.reference

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

Modifier and Type	Method	Description
<C extends CtActualTypeContainer> C	CtTypeParameterReferenceImpl.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)
<E extends CtElement> E	CtTypeMemberWildcardImportReferenceImpl.addAnnotation(CtAnnotation<? extends Annotation> annotation)
boolean	CtTypeParameterReferenceImpl.removeActualTypeArgument(CtTypeReference<?> actualTypeArgument)
boolean	CtTypeMemberWildcardImportReferenceImpl.removeAnnotation(CtAnnotation<? extends Annotation> annotation)
<C extends CtActualTypeContainer> C	CtTypeParameterReferenceImpl.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)
<E extends CtElement> E	CtTypeMemberWildcardImportReferenceImpl.setAnnotations(List<CtAnnotation<? extends Annotation>> annotations)
<E extends CtElement> E	CtUnboundVariableReferenceImpl.setAnnotations(List<CtAnnotation<? extends Annotation>> annotations)
<E extends CtElement> E	CtReferenceImpl.setComments(List<CtComment> comments)
<E extends CtElement> E	CtTypeMemberWildcardImportReferenceImpl.setImplicit(boolean implicit)
<T extends CtReference> T	CtTypeMemberWildcardImportReferenceImpl.setSimpleName(String simpleName)
<T extends CtReference> T	CtWildcardReferenceImpl.setSimpleName(String simplename)
CtTypeParameterReferenceImpl	CtTypeParameterReferenceImpl.setSimplyQualified(boolean isSimplyQualified)