Package | Description |
---|---|
spoon.metamodel |
Ready to go meta?
This package contains classes that model the Spoon metamodel itself.
|
spoon.pattern | |
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.factory |
This package defines all the sub-factories for the Spoon meta-model.
|
spoon.reflect.reference |
This package defines the references to program elements for the meta-model.
|
spoon.reflect.visitor |
This package defines visitor, scanner, and scanner-based query API for Java programs reified in the meta-model.
|
spoon.reflect.visitor.filter |
This package contains a set of useful filters when querying the model.
|
spoon.support |
This package contains some default implementations for commonly used processing tasks.
|
spoon.support.compiler | |
spoon.support.compiler.jdt | |
spoon.support.reflect.code | |
spoon.support.reflect.declaration | |
spoon.support.reflect.reference | |
spoon.support.visitor | |
spoon.support.visitor.clone | |
spoon.support.visitor.java.internal | |
spoon.support.visitor.replace | |
spoon.template |
This package defines a framework for well-typed pure-Java templates.
|
Modifier and Type | Method and Description |
---|---|
CtTypeReference<?> |
MMMethod.getReturnType() |
CtTypeReference<?> |
MetamodelProperty.getTypeOfField()
Return the type of the field
for List<String> field the ValueType is List
for String field the ValueType is String
|
CtTypeReference<?> |
MetamodelProperty.getTypeofItems()
Returns the type of the property
for List<String> field the ValueType is String
for String field the ValueType is String (when getContainerKind ==
ContainerKind.SINGLE , MetamodelProperty.getTypeofItems() == MetamodelProperty.getTypeOfField() . |
CtTypeReference<?> |
MMMethod.getValueType() |
Modifier and Type | Method and Description |
---|---|
PatternParameterConfigurator |
PatternParameterConfigurator.byType(CtTypeReference<?> type)
type referred by
CtTypeReference `type` and all the references (with same actual type arguments)
to that type are subject for substitution by current parameter |
Modifier and Type | Method and Description |
---|---|
CtTypeReference<A> |
CtTypeAccess.getAccessedType()
Returns type represented and contained in the type access.
|
CtTypeReference<T> |
CtConstructorCall.getType() |
CtTypeReference<T> |
CtVariableAccess.getType() |
CtTypeReference<T> |
CtInvocation.getType()
Return the type returned by the invocation.
|
CtTypeReference<java.lang.Void> |
CtTypeAccess.getType()
Returns always VOID.
|
CtTypeReference<T> |
CtCatchVariable.getType()
Returns type reference of the exception variable in a catch.
|
CtTypeReference<T> |
CtSuperAccess.getType() |
Modifier and Type | Method and Description |
---|---|
java.util.List<CtTypeReference<?>> |
CtConstructorCall.getActualTypeArguments()
Delegate to the executable reference of the constructor call.
|
java.util.List<CtTypeReference<?>> |
CtInvocation.getActualTypeArguments()
Delegate to the executable reference of the invocation.
|
java.util.List<CtTypeReference<?>> |
CtNewClass.getActualTypeArguments()
Delegate to the executable reference of the new class.
|
java.util.List<CtTypeReference<?>> |
CtExpression.getTypeCasts()
Returns the type casts if any.
|
Modifier and Type | Method and Description |
---|---|
<T extends CtActualTypeContainer> |
CtConstructorCall.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)
Delegate to the executable reference of the constructor call.
|
<T extends CtActualTypeContainer> |
CtInvocation.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)
Delegate to the executable reference of the invocation.
|
<T extends CtActualTypeContainer> |
CtNewClass.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)
Delegate to the executable reference of the new class.
|
<C extends CtExpression<T>> |
CtExpression.addTypeCast(CtTypeReference<?> type)
Adds a type cast.
|
<C extends CtTypeAccess<A>> |
CtTypeAccess.setAccessedType(CtTypeReference<A> accessedType)
Set the accessed type.
|
<C extends CtTypedElement> |
CtCatchVariable.setType(CtTypeReference<T> type) |
<C extends CtTypedElement> |
CtTypeAccess.setType(CtTypeReference<java.lang.Void> type) |
Modifier and Type | Method and Description |
---|---|
<T extends CtActualTypeContainer> |
CtConstructorCall.setActualTypeArguments(java.util.List<? extends CtTypeReference<?>> actualTypeArguments)
Delegate to the executable reference of the constructor call.
|
<T extends CtActualTypeContainer> |
CtInvocation.setActualTypeArguments(java.util.List<? extends CtTypeReference<?>> actualTypeArguments)
Delegate to the executable reference of the invocation.
|
<T extends CtActualTypeContainer> |
CtNewClass.setActualTypeArguments(java.util.List<? extends CtTypeReference<?>> actualTypeArguments)
Delegate to the executable reference of the new class.
|
<T1 extends CtExecutable<T>> |
CtLambda.setThrownTypes(java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes) |
<C extends CtExpression<T>> |
CtExpression.setTypeCasts(java.util.List<CtTypeReference<?>> types)
Sets the type casts.
|
Modifier and Type | Method and Description |
---|---|
CtTypeReference<A> |
CtAnnotation.getAnnotationType()
Returns the annotation type of this annotation.
|
CtTypeReference<T> |
CtType.getReference()
Returns the corresponding type reference.
|
CtTypeReference |
CtProvidedService.getServiceType() |
CtTypeReference |
CtUsedService.getServiceType() |
CtTypeReference<?> |
CtTypeInformation.getSuperclass()
Returns the class type directly extended by this class.
|
CtTypeReference<T> |
CtTypedElement.getType()
Gets this element's type.
|
CtTypeReference<?> |
CtTypeInformation.getTypeErasure() |
Modifier and Type | Method and Description |
---|---|
java.util.List<CtTypeReference<?>> |
CtCompilationUnit.getDeclaredTypeReferences()
Gets references to all the types declared in this compilation unit.
|
java.util.List<CtTypeReference> |
CtProvidedService.getImplementationTypes() |
java.util.List<CtTypeReference<?>> |
CtMultiTypedElement.getMultiTypes()
Gets all types of the element.
|
java.util.Set<CtTypeReference<?>> |
CtElement.getReferencedTypes()
Calculates and returns the set of all the types referenced by this
element (and sub-elements in the AST).
|
java.util.Set<CtTypeReference<?>> |
CtTypeInformation.getSuperInterfaces()
Returns the interface types directly implemented by this class or
extended by this interface.
|
java.util.Set<CtTypeReference<? extends java.lang.Throwable>> |
CtExecutable.getThrownTypes()
Returns the exceptions and other throwables listed in this method or
constructor's throws clause.
|
java.util.Set<CtTypeReference<?>> |
CtType.getUsedTypes(boolean includeSamePackage)
Returns the types used by this type.
|
Modifier and Type | Method and Description |
---|---|
CtCompilationUnit |
CtCompilationUnit.addDeclaredTypeReference(CtTypeReference<?> type)
Add a type reference to the list of declared types
|
<T extends CtProvidedService> |
CtProvidedService.addImplementationType(CtTypeReference usedType) |
<T extends CtMultiTypedElement> |
CtMultiTypedElement.addMultiType(CtTypeReference<?> ref)
Adds a type for the element.
|
<S,C extends CtType<java.lang.Object>> |
CtTypeParameter.addSuperInterface(CtTypeReference<S> interfac) |
<S,C extends CtType<T>> |
CtType.addSuperInterface(CtTypeReference<S> interfac) |
<T extends CtExecutable<java.lang.Void>> |
CtAnonymousExecutable.addThrownType(CtTypeReference<? extends java.lang.Throwable> throwType) |
<T extends CtExecutable<R>> |
CtExecutable.addThrownType(CtTypeReference<? extends java.lang.Throwable> throwType)
add a thrown type.
|
<A extends java.lang.annotation.Annotation> |
CtElement.getAnnotation(CtTypeReference<A> annotationType)
Gets the annotation element for a given annotation type.
|
CtConstructor<T> |
CtClass.getConstructor(CtTypeReference<?>... parameterTypes)
Returns the constructor of the class that takes the given argument types.
|
<R> CtMethod<R> |
CtType.getMethod(CtTypeReference<R> returnType,
java.lang.String name,
CtTypeReference<?>... parameterTypes)
Gets a method from its return type, name, and parameter types.
|
<R> CtMethod<R> |
CtType.getMethod(CtTypeReference<R> returnType,
java.lang.String name,
CtTypeReference<?>... parameterTypes)
Gets a method from its return type, name, and parameter types.
|
<R> CtMethod<R> |
CtType.getMethod(java.lang.String name,
CtTypeReference<?>... parameterTypes)
Gets a method from its name and parameter types.
|
java.util.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.
|
boolean |
CtTypeInformation.isSubtypeOf(CtTypeReference<?> type)
Returns true if the referenced type is a sub-type of the given type.
|
boolean |
CtMultiTypedElement.removeMultiType(CtTypeReference<?> ref)
Removes a type for the element.
|
<S> boolean |
CtType.removeSuperInterface(CtTypeReference<S> interfac) |
boolean |
CtExecutable.removeThrownType(CtTypeReference<? extends java.lang.Throwable> throwType)
remove a thrown type.
|
<T extends CtAnnotation<A>> |
CtAnnotation.setAnnotationType(CtTypeReference<? extends java.lang.annotation.Annotation> type)
Sets the annotation's type.
|
<T extends CtProvidedService> |
CtProvidedService.setServiceType(CtTypeReference providingType) |
<T extends CtUsedService> |
CtUsedService.setServiceType(CtTypeReference providingType) |
<C extends CtType<T>> |
CtInterface.setSuperclass(CtTypeReference<?> superClass) |
<C extends CtType<T>> |
CtAnnotationType.setSuperclass(CtTypeReference<?> superClass) |
<C extends CtType<T>> |
CtType.setSuperclass(CtTypeReference<?> superClass)
Sets the superclass type.
|
<C extends CtType<T>> |
CtEnum.setSuperclass(CtTypeReference<?> superClass) |
<C extends CtTypedElement> |
CtTypedElement.setType(CtTypeReference<T> type)
Sets this element's type.
|
<C extends CtTypedElement> |
CtConstructor.setType(CtTypeReference<T> type) |
<C extends CtTypedElement> |
CtAnonymousExecutable.setType(CtTypeReference<java.lang.Void> type) |
Modifier and Type | Method and Description |
---|---|
CtCompilationUnit |
CtCompilationUnit.setDeclaredTypeReferences(java.util.List<CtTypeReference<?>> types)
Sets the references to types declared in this compilation unit.
|
<T extends CtProvidedService> |
CtProvidedService.setImplementationTypes(java.util.List<CtTypeReference> usedTypes) |
<T extends CtMultiTypedElement> |
CtMultiTypedElement.setMultiTypes(java.util.List<CtTypeReference<?>> types)
Adds a type for the element.
|
<C extends CtType<java.lang.Object>> |
CtTypeParameter.setSuperInterfaces(java.util.Set<CtTypeReference<?>> interfaces) |
<C extends CtType<T>> |
CtAnnotationType.setSuperInterfaces(java.util.Set<CtTypeReference<?>> interfaces) |
<C extends CtType<T>> |
CtType.setSuperInterfaces(java.util.Set<CtTypeReference<?>> interfaces)
Sets the super interfaces of this type.
|
<T1 extends CtExecutable<T>> |
CtAnnotationMethod.setThrownTypes(java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes) |
<T extends CtExecutable<java.lang.Void>> |
CtAnonymousExecutable.setThrownTypes(java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes) |
<T extends CtExecutable<R>> |
CtExecutable.setThrownTypes(java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes)
Sets the thrown types.
|
<C extends CtExpression<A>> |
CtAnnotation.setTypeCasts(java.util.List<CtTypeReference<?>> types) |
Modifier and Type | Field and Description |
---|---|
CtTypeReference<java.lang.Boolean> |
TypeFactory.BOOLEAN |
CtTypeReference<java.lang.Boolean> |
TypeFactory.BOOLEAN_PRIMITIVE |
CtTypeReference<java.lang.Byte> |
TypeFactory.BYTE |
CtTypeReference<java.lang.Byte> |
TypeFactory.BYTE_PRIMITIVE |
CtTypeReference<java.lang.Character> |
TypeFactory.CHARACTER |
CtTypeReference<java.lang.Character> |
TypeFactory.CHARACTER_PRIMITIVE |
CtTypeReference<java.util.Collection> |
TypeFactory.COLLECTION |
CtTypeReference<java.util.Date> |
TypeFactory.DATE |
CtTypeReference<java.lang.Double> |
TypeFactory.DOUBLE |
CtTypeReference<java.lang.Double> |
TypeFactory.DOUBLE_PRIMITIVE |
CtTypeReference<java.lang.Enum> |
TypeFactory.ENUM |
CtTypeReference<java.lang.Float> |
TypeFactory.FLOAT |
CtTypeReference<java.lang.Float> |
TypeFactory.FLOAT_PRIMITIVE |
CtTypeReference<java.lang.Integer> |
TypeFactory.INTEGER |
CtTypeReference<java.lang.Integer> |
TypeFactory.INTEGER_PRIMITIVE |
CtTypeReference<java.lang.Iterable> |
TypeFactory.ITERABLE |
CtTypeReference<java.util.List> |
TypeFactory.LIST |
CtTypeReference<java.lang.Long> |
TypeFactory.LONG |
CtTypeReference<java.lang.Long> |
TypeFactory.LONG_PRIMITIVE |
CtTypeReference<java.util.Map> |
TypeFactory.MAP |
CtTypeReference<?> |
TypeFactory.NULL_TYPE |
CtTypeReference<java.lang.Object> |
TypeFactory.OBJECT |
CtTypeReference<?> |
TypeFactory.OMITTED_TYPE_ARG_TYPE |
CtTypeReference<java.util.Set> |
TypeFactory.SET |
CtTypeReference<java.lang.Short> |
TypeFactory.SHORT |
CtTypeReference<java.lang.Short> |
TypeFactory.SHORT_PRIMITIVE |
CtTypeReference<java.lang.String> |
TypeFactory.STRING |
CtTypeReference<java.lang.Void> |
TypeFactory.VOID |
CtTypeReference<java.lang.Void> |
TypeFactory.VOID_PRIMITIVE |
Modifier and Type | Method and Description |
---|---|
CtTypeReference<java.lang.Boolean> |
TypeFactory.booleanPrimitiveType()
Returns a reference on the boolean primitive type.
|
CtTypeReference<java.lang.Boolean> |
TypeFactory.booleanType()
Returns a reference on the boolean type.
|
CtTypeReference<java.lang.Byte> |
TypeFactory.bytePrimitiveType()
Returns a reference on the byte primitive type.
|
CtTypeReference<java.lang.Byte> |
TypeFactory.byteType()
Returns a reference on the byte type.
|
CtTypeReference<java.lang.Character> |
TypeFactory.characterPrimitiveType()
Returns a reference on the character primitive type.
|
CtTypeReference<java.lang.Character> |
TypeFactory.characterType()
Returns a reference on the character type.
|
<T> CtTypeReference<T> |
CodeFactory.createCtTypeReference(java.lang.Class<?> originalClass)
Creates a type reference.
|
<T> CtTypeReference<T> |
Factory.createCtTypeReference(java.lang.Class<?> originalClass) |
<T> CtTypeReference<T> |
FactoryImpl.createCtTypeReference(java.lang.Class<?> originalClass) |
<T> CtTypeReference<T> |
TypeFactory.createReference(java.lang.Class<T> type) |
<T> CtTypeReference<T> |
TypeFactory.createReference(java.lang.Class<T> type,
boolean includingFormalTypeParameter)
Creates a reference to a simple type
|
<T> CtTypeReference<T> |
TypeFactory.createReference(CtType<T> type)
Create a reference to a simple type
|
<T> CtTypeReference<T> |
TypeFactory.createReference(CtType<T> type,
boolean includingFormalTypeParameter) |
<T> CtTypeReference<T> |
TypeFactory.createReference(java.lang.String qualifiedName)
Create a reference to a simple type
|
<T> CtTypeReference<T> |
Factory.createReference(java.lang.String qualifiedName) |
<T> CtTypeReference<T> |
FactoryImpl.createReference(java.lang.String qualifiedName) |
<T> CtTypeReference<T> |
TypeFactory.createSimplyQualifiedReference(java.lang.String qualifiedName)
Create a reference to a simple type, setting the beginning of its fully qualified name as implicit
|
<T> CtTypeReference<T> |
Factory.createSimplyQualifiedReference(java.lang.String qualifiedName) |
<T> CtTypeReference<T> |
FactoryImpl.createSimplyQualifiedReference(java.lang.String qualifiedName) |
<T> CtTypeReference<T> |
CoreFactory.createTypeReference()
Creates a type reference.
|
<T> CtTypeReference<T> |
Factory.createTypeReference() |
<T> CtTypeReference<T> |
FactoryImpl.createTypeReference() |
CtTypeReference<java.util.Date> |
TypeFactory.dateType()
Returns a reference on the date type.
|
CtTypeReference<java.lang.Double> |
TypeFactory.doublePrimitiveType()
Returns a reference on the double primitive type.
|
CtTypeReference<java.lang.Double> |
TypeFactory.doubleType()
Returns a reference on the double type.
|
CtTypeReference<java.lang.Float> |
TypeFactory.floatPrimitiveType()
Returns a reference on the float primitive type.
|
CtTypeReference<java.lang.Float> |
TypeFactory.floatType()
Returns a reference on the float type.
|
CtTypeReference |
TypeFactory.getDefaultBoundingType()
Returns the default bounding type value
|
CtTypeReference<java.lang.Integer> |
TypeFactory.integerPrimitiveType()
Returns a reference on the integer primitive type.
|
CtTypeReference<java.lang.Integer> |
TypeFactory.integerType()
Returns a reference on the integer type.
|
CtTypeReference<java.lang.Long> |
TypeFactory.longPrimitiveType()
Returns a reference on the long primitive type.
|
CtTypeReference<java.lang.Long> |
TypeFactory.longType()
Returns a reference on the long type.
|
CtTypeReference<?> |
TypeFactory.nullType()
Returns a reference on the null type (type of null).
|
CtTypeReference<java.lang.Object> |
TypeFactory.objectType()
Returns a reference on the object type.
|
CtTypeReference<java.lang.Short> |
TypeFactory.shortPrimitiveType()
Returns a reference on the short primitive type.
|
CtTypeReference<java.lang.Short> |
TypeFactory.shortType()
Returns a reference on the short type.
|
CtTypeReference<java.lang.String> |
TypeFactory.stringType()
Returns a reference on the string type.
|
CtTypeReference<java.lang.Void> |
TypeFactory.voidPrimitiveType()
Returns a reference on the void primitive type.
|
CtTypeReference<java.lang.Void> |
TypeFactory.voidType()
Returns a reference on the void type.
|
Modifier and Type | Method and Description |
---|---|
java.util.List<CtTypeReference<?>> |
TypeFactory.createReferences(java.util.List<java.lang.Class<?>> classes)
Creates a collection of type references from a collection of classes.
|
java.util.List<CtTypeReference<?>> |
Factory.createReferences(java.util.List<java.lang.Class<?>> classes) |
java.util.List<CtTypeReference<?>> |
FactoryImpl.createReferences(java.util.List<java.lang.Class<?>> classes) |
Modifier and Type | Method and Description |
---|---|
<A extends java.lang.annotation.Annotation> |
AnnotationFactory.annotate(CtElement element,
CtTypeReference<A> annotationType)
Adds an annotation to an element.
|
<A extends java.lang.annotation.Annotation> |
AnnotationFactory.annotate(CtElement element,
CtTypeReference<A> annotationType,
java.lang.String annotationElementName,
java.lang.Object value)
Creates/updates an element's annotation value.
|
<R,B extends R> |
MethodFactory.create(CtClass<?> target,
java.util.Set<ModifierKind> modifiers,
CtTypeReference<R> returnType,
java.lang.String name,
java.util.List<CtParameter<?>> parameters,
java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes,
CtBlock<B> body)
Creates a method.
|
<T> CtField<T> |
FieldFactory.create(CtType<?> target,
java.util.Set<ModifierKind> modifiers,
CtTypeReference<T> type,
java.lang.String name)
Creates a field.
|
<T> CtField<T> |
FieldFactory.create(CtType<?> target,
java.util.Set<ModifierKind> modifiers,
CtTypeReference<T> type,
java.lang.String name,
CtExpression<T> defaultExpression)
Creates a field.
|
<T> CtMethod<T> |
MethodFactory.create(CtType<?> target,
java.util.Set<ModifierKind> modifiers,
CtTypeReference<T> returnType,
java.lang.String name,
java.util.List<CtParameter<?>> parameters,
java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes)
Creates an empty method.
|
<A extends java.lang.annotation.Annotation> |
CodeFactory.createAnnotation(CtTypeReference<A> annotationType)
Creates an annotation.
|
<A extends java.lang.annotation.Annotation> |
Factory.createAnnotation(CtTypeReference<A> annotationType) |
<A extends java.lang.annotation.Annotation> |
FactoryImpl.createAnnotation(CtTypeReference<A> annotationType) |
CtArrayTypeReference<?> |
TypeFactory.createArrayReference(CtTypeReference<?> reference,
int n)
Creates a reference to a n-dimension array of given type.
|
CtArrayTypeReference<?> |
Factory.createArrayReference(CtTypeReference<?> reference,
int n) |
CtArrayTypeReference<?> |
FactoryImpl.createArrayReference(CtTypeReference<?> reference,
int n) |
<T> CtArrayTypeReference<T[]> |
TypeFactory.createArrayReference(CtTypeReference<T> reference)
Creates a reference to a one-dimension array of given type.
|
<T> CtArrayTypeReference<T[]> |
Factory.createArrayReference(CtTypeReference<T> reference) |
<T> CtArrayTypeReference<T[]> |
FactoryImpl.createArrayReference(CtTypeReference<T> reference) |
<T> CtCatchVariable<T> |
CodeFactory.createCatchVariable(CtTypeReference<T> type,
java.lang.String name,
ModifierKind... modifierKinds)
Creates a catch variable declaration.
|
<T> CtCatchVariable<T> |
Factory.createCatchVariable(CtTypeReference<T> type,
java.lang.String name,
ModifierKind... modifierKinds) |
<T> CtCatchVariable<T> |
FactoryImpl.createCatchVariable(CtTypeReference<T> type,
java.lang.String name,
ModifierKind... modifierKinds) |
<T> CtFieldAccess<java.lang.Class<T>> |
CodeFactory.createClassAccess(CtTypeReference<T> type)
Creates a class access expression of the form
C.class . |
<T> CtFieldAccess<java.lang.Class<T>> |
Factory.createClassAccess(CtTypeReference<T> type) |
<T> CtFieldAccess<java.lang.Class<T>> |
FactoryImpl.createClassAccess(CtTypeReference<T> type) |
<T> CtConstructorCall<T> |
CodeFactory.createConstructorCall(CtTypeReference<T> type,
CtExpression<?>... parameters)
Creates a constructor call.
|
<T> CtConstructorCall<T> |
Factory.createConstructorCall(CtTypeReference<T> type,
CtExpression<?>... parameters) |
<T> CtConstructorCall<T> |
FactoryImpl.createConstructorCall(CtTypeReference<T> type,
CtExpression<?>... parameters) |
<T> CtField<T> |
CodeFactory.createCtField(java.lang.String name,
CtTypeReference<T> type,
java.lang.String exp,
ModifierKind... visibilities)
Creates a field.
|
<T> CtField<T> |
Factory.createCtField(java.lang.String name,
CtTypeReference<T> type,
java.lang.String exp,
ModifierKind... visibilities) |
<T> CtField<T> |
FactoryImpl.createCtField(java.lang.String name,
CtTypeReference<T> type,
java.lang.String exp,
ModifierKind... visibilities) |
CtField |
Factory.createField(CtType<?> target,
java.util.Set<ModifierKind> modifiers,
CtTypeReference type,
java.lang.String name) |
CtField |
FactoryImpl.createField(CtType<?> target,
java.util.Set<ModifierKind> modifiers,
CtTypeReference type,
java.lang.String name) |
CtField |
Factory.createField(CtType<?> target,
java.util.Set<ModifierKind> modifiers,
CtTypeReference type,
java.lang.String name,
CtExpression defaultExpression) |
CtField |
FactoryImpl.createField(CtType<?> target,
java.util.Set<ModifierKind> modifiers,
CtTypeReference type,
java.lang.String name,
CtExpression defaultExpression) |
<T> CtLocalVariable<T> |
CodeFactory.createLocalVariable(CtTypeReference<T> type,
java.lang.String name,
CtExpression<T> defaultExpression)
Creates a local variable declaration.
|
<T> CtLocalVariable<T> |
Factory.createLocalVariable(CtTypeReference<T> type,
java.lang.String name,
CtExpression<T> defaultExpression) |
<T> CtLocalVariable<T> |
FactoryImpl.createLocalVariable(CtTypeReference<T> type,
java.lang.String name,
CtExpression<T> defaultExpression) |
<T> CtLocalVariableReference<T> |
CodeFactory.createLocalVariableReference(CtTypeReference<T> type,
java.lang.String name)
Creates a local variable reference with its name an type (weak
referencing).
|
<T> CtLocalVariableReference<T> |
Factory.createLocalVariableReference(CtTypeReference<T> type,
java.lang.String name) |
<T> CtLocalVariableReference<T> |
FactoryImpl.createLocalVariableReference(CtTypeReference<T> type,
java.lang.String name) |
CtMethod |
Factory.createMethod(CtClass<?> target,
java.util.Set<ModifierKind> modifiers,
CtTypeReference returnType,
java.lang.String name,
java.util.List<CtParameter<?>> parameters,
java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes,
CtBlock body) |
CtMethod |
FactoryImpl.createMethod(CtClass<?> target,
java.util.Set<ModifierKind> modifiers,
CtTypeReference returnType,
java.lang.String name,
java.util.List<CtParameter<?>> parameters,
java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes,
CtBlock body) |
CtMethod |
Factory.createMethod(CtType<?> target,
java.util.Set<ModifierKind> modifiers,
CtTypeReference returnType,
java.lang.String name,
java.util.List<CtParameter<?>> parameters,
java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes) |
CtMethod |
FactoryImpl.createMethod(CtType<?> target,
java.util.Set<ModifierKind> modifiers,
CtTypeReference returnType,
java.lang.String name,
java.util.List<CtParameter<?>> parameters,
java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes) |
<T> CtParameter<T> |
Factory.createParameter(CtExecutable<?> parent,
CtTypeReference<T> type,
java.lang.String name) |
<T> CtParameter<T> |
FactoryImpl.createParameter(CtExecutable<?> parent,
CtTypeReference<T> type,
java.lang.String name) |
<T> CtParameter<T> |
ExecutableFactory.createParameter(CtExecutable<?> parent,
CtTypeReference<T> type,
java.lang.String name)
Creates a new parameter.
|
CtProvidedService |
Factory.createProvidedService(CtTypeReference ctTypeReference) |
CtProvidedService |
ModuleFactory.createProvidedService(CtTypeReference typeReference) |
CtProvidedService |
FactoryImpl.createProvidedService(CtTypeReference ctTypeReference) |
<T> CtExecutableReference<T> |
ExecutableFactory.createReference(CtTypeReference<?> declaringType,
boolean isStatic,
CtTypeReference<T> type,
java.lang.String methodName,
CtTypeReference<?>... parameterTypes)
Creates an executable reference.
|
<T> CtExecutableReference<T> |
ExecutableFactory.createReference(CtTypeReference<?> declaringType,
boolean isStatic,
CtTypeReference<T> type,
java.lang.String methodName,
CtTypeReference<?>... parameterTypes)
Creates an executable reference.
|
<T> CtExecutableReference<T> |
ExecutableFactory.createReference(CtTypeReference<?> declaringType,
boolean isStatic,
CtTypeReference<T> type,
java.lang.String methodName,
CtTypeReference<?>... parameterTypes)
Creates an executable reference.
|
<T> CtExecutableReference<T> |
ExecutableFactory.createReference(CtTypeReference<?> declaringType,
boolean isStatic,
CtTypeReference<T> type,
java.lang.String methodName,
java.util.List<CtTypeReference<?>> parameterTypes)
Creates an executable reference.
|
<T> CtExecutableReference<T> |
ExecutableFactory.createReference(CtTypeReference<?> declaringType,
boolean isStatic,
CtTypeReference<T> type,
java.lang.String methodName,
java.util.List<CtTypeReference<?>> parameterTypes)
Creates an executable reference.
|
<T> CtFieldReference<T> |
FieldFactory.createReference(CtTypeReference<?> declaringType,
CtTypeReference<T> type,
java.lang.String fieldName)
Creates a field reference.
|
<T> CtFieldReference<T> |
FieldFactory.createReference(CtTypeReference<?> declaringType,
CtTypeReference<T> type,
java.lang.String fieldName)
Creates a field reference.
|
<T> CtExecutableReference<T> |
ExecutableFactory.createReference(CtTypeReference<?> declaringType,
CtTypeReference<T> type,
java.lang.String methodName,
CtTypeReference<?>... parameterTypes)
Creates an executable reference.
|
<T> CtExecutableReference<T> |
ExecutableFactory.createReference(CtTypeReference<?> declaringType,
CtTypeReference<T> type,
java.lang.String methodName,
CtTypeReference<?>... parameterTypes)
Creates an executable reference.
|
<T> CtExecutableReference<T> |
ExecutableFactory.createReference(CtTypeReference<?> declaringType,
CtTypeReference<T> type,
java.lang.String methodName,
CtTypeReference<?>... parameterTypes)
Creates an executable reference.
|
<T> CtExecutableReference<T> |
ExecutableFactory.createReference(CtTypeReference<?> declaringType,
CtTypeReference<T> type,
java.lang.String methodName,
java.util.List<CtTypeReference<?>> parameterTypes)
Creates an executable reference.
|
<T> CtExecutableReference<T> |
ExecutableFactory.createReference(CtTypeReference<?> declaringType,
CtTypeReference<T> type,
java.lang.String methodName,
java.util.List<CtTypeReference<?>> parameterTypes)
Creates an executable reference.
|
<T> CtExecutableReference<T> |
ConstructorFactory.createReference(CtTypeReference<T> type,
CtExpression<?>... parameters)
Creates a constructor reference.
|
<T> CtThisAccess<T> |
CodeFactory.createThisAccess(CtTypeReference<T> type)
Creates an explicit access to a
this variable (of the form
type.this ). |
<T> CtThisAccess<T> |
Factory.createThisAccess(CtTypeReference<T> type) |
<T> CtThisAccess<T> |
FactoryImpl.createThisAccess(CtTypeReference<T> type) |
<T> CtThisAccess<T> |
CodeFactory.createThisAccess(CtTypeReference<T> type,
boolean isImplicit)
Creates an access to a
this variable (of the form
type.this ). |
<T> CtThisAccess<T> |
Factory.createThisAccess(CtTypeReference<T> type,
boolean isImplicit) |
<T> CtThisAccess<T> |
FactoryImpl.createThisAccess(CtTypeReference<T> type,
boolean isImplicit) |
<T> CtTypeAccess<T> |
CodeFactory.createTypeAccess(CtTypeReference<T> accessedType)
Creates a accessed type.
|
<T> CtTypeAccess<T> |
Factory.createTypeAccess(CtTypeReference<T> accessedType) |
<T> CtTypeAccess<T> |
FactoryImpl.createTypeAccess(CtTypeReference<T> accessedType) |
<T> CtTypeAccess<T> |
CodeFactory.createTypeAccess(CtTypeReference<T> accessedType,
boolean isImplicit)
Creates a accessed type.
|
<T> CtTypeAccess<T> |
Factory.createTypeAccess(CtTypeReference<T> accessedType,
boolean isImplicit) |
<T> CtTypeAccess<T> |
FactoryImpl.createTypeAccess(CtTypeReference<T> accessedType,
boolean isImplicit) |
<T> CtTypeAccess<T> |
CodeFactory.createTypeAccessWithoutCloningReference(CtTypeReference<T> accessedType)
Creates a accessed type, see
CodeFactory.createTypeAccess(CtTypeReference) for details. |
<T> CtTypeAccess<T> |
Factory.createTypeAccessWithoutCloningReference(CtTypeReference<T> accessedType) |
<T> CtTypeAccess<T> |
FactoryImpl.createTypeAccessWithoutCloningReference(CtTypeReference<T> accessedType) |
CtTypeMemberWildcardImportReference |
TypeFactory.createTypeMemberWildcardImportReference(CtTypeReference typeReference)
Create a wildcard reference to a simple type
|
CtTypeMemberWildcardImportReference |
FactoryImpl.createTypeMemberWildcardImportReference(CtTypeReference typeReference) |
CtTypeMemberWildcardImportReference |
Factory.createTypeMemberWildcardImportReference(CtTypeReference<?> typeReference) |
CtUsedService |
Factory.createUsedService(CtTypeReference typeReference) |
CtUsedService |
ModuleFactory.createUsedService(CtTypeReference typeReference) |
CtUsedService |
FactoryImpl.createUsedService(CtTypeReference typeReference) |
Modifier and Type | Method and Description |
---|---|
<R,B extends R> |
MethodFactory.create(CtClass<?> target,
java.util.Set<ModifierKind> modifiers,
CtTypeReference<R> returnType,
java.lang.String name,
java.util.List<CtParameter<?>> parameters,
java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes,
CtBlock<B> body)
Creates a method.
|
<T> CtConstructor<T> |
ConstructorFactory.create(CtClass<T> target,
java.util.Set<ModifierKind> modifiers,
java.util.List<CtParameter<?>> parameters,
java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes)
Creates an empty constructor.
|
<T> CtConstructor<T> |
ConstructorFactory.create(CtClass<T> target,
java.util.Set<ModifierKind> modifiers,
java.util.List<CtParameter<?>> parameters,
java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes,
CtBlock<T> body)
Creates a constructor.
|
<T> CtMethod<T> |
MethodFactory.create(CtType<?> target,
java.util.Set<ModifierKind> modifiers,
CtTypeReference<T> returnType,
java.lang.String name,
java.util.List<CtParameter<?>> parameters,
java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes)
Creates an empty method.
|
CtConstructor |
Factory.createConstructor(CtClass target,
java.util.Set<ModifierKind> modifiers,
java.util.List<CtParameter<?>> parameters,
java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes) |
CtConstructor |
FactoryImpl.createConstructor(CtClass target,
java.util.Set<ModifierKind> modifiers,
java.util.List<CtParameter<?>> parameters,
java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes) |
CtConstructor |
Factory.createConstructor(CtClass target,
java.util.Set<ModifierKind> modifiers,
java.util.List<CtParameter<?>> parameters,
java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes,
CtBlock body) |
CtConstructor |
FactoryImpl.createConstructor(CtClass target,
java.util.Set<ModifierKind> modifiers,
java.util.List<CtParameter<?>> parameters,
java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes,
CtBlock body) |
<T> CtIntersectionTypeReference<T> |
TypeFactory.createIntersectionTypeReferenceWithBounds(java.util.List<CtTypeReference<?>> bounds)
Creates an intersection type reference.
|
<T> CtIntersectionTypeReference<T> |
Factory.createIntersectionTypeReferenceWithBounds(java.util.List<CtTypeReference<?>> bounds) |
<T> CtIntersectionTypeReference<T> |
FactoryImpl.createIntersectionTypeReferenceWithBounds(java.util.List<CtTypeReference<?>> bounds) |
CtMethod |
Factory.createMethod(CtClass<?> target,
java.util.Set<ModifierKind> modifiers,
CtTypeReference returnType,
java.lang.String name,
java.util.List<CtParameter<?>> parameters,
java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes,
CtBlock body) |
CtMethod |
FactoryImpl.createMethod(CtClass<?> target,
java.util.Set<ModifierKind> modifiers,
CtTypeReference returnType,
java.lang.String name,
java.util.List<CtParameter<?>> parameters,
java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes,
CtBlock body) |
CtMethod |
Factory.createMethod(CtType<?> target,
java.util.Set<ModifierKind> modifiers,
CtTypeReference returnType,
java.lang.String name,
java.util.List<CtParameter<?>> parameters,
java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes) |
CtMethod |
FactoryImpl.createMethod(CtType<?> target,
java.util.Set<ModifierKind> modifiers,
CtTypeReference returnType,
java.lang.String name,
java.util.List<CtParameter<?>> parameters,
java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes) |
<T> CtExecutableReference<T> |
ExecutableFactory.createReference(CtTypeReference<?> declaringType,
boolean isStatic,
CtTypeReference<T> type,
java.lang.String methodName,
java.util.List<CtTypeReference<?>> parameterTypes)
Creates an executable reference.
|
<T> CtExecutableReference<T> |
ExecutableFactory.createReference(CtTypeReference<?> declaringType,
CtTypeReference<T> type,
java.lang.String methodName,
java.util.List<CtTypeReference<?>> parameterTypes)
Creates an executable reference.
|
Modifier and Type | Interface and Description |
---|---|
interface |
CtArrayTypeReference<T>
This interface defines a reference to an array.
|
interface |
CtIntersectionTypeReference<T>
This interface defines a reference to an intersection type in generics or in casts.
|
interface |
CtTypeParameterReference
This interface defines a reference to a type parameter (aka generics).
|
interface |
CtWildcardReference
Represents a wildcard in generic type annotations, i.e.
|
Modifier and Type | Method and Description |
---|---|
<C extends CtTypeReference<T>> |
CtTypeReference.setDeclaringType(CtTypeReference<?> type)
Sets the reference to the declaring type.
|
<C extends CtTypeReference<T>> |
CtTypeReference.setPackage(CtPackageReference pack)
Sets the reference to the declaring package.
|
Modifier and Type | Method and Description |
---|---|
CtTypeReference<?> |
CtTypeReference.box()
Returns the corresponding non-primitive type for a primitive type (the
same type otherwise).
|
CtTypeReference<T> |
CtTypeReference.clone() |
CtTypeReference<?> |
CtTypeReference.getAccessType()
Computes nearest access path parent to this type from the context of this type reference.
|
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. |
CtTypeReference<?> |
CtWildcardReference.getBoundingType()
A type parameter can have an
extends clause which declare
one (CtTypeReference or more (CtIntersectionTypeReference references. |
CtTypeReference<?> |
CtArrayTypeReference.getComponentType()
Gets the type of the elements contained in this array.
|
CtTypeReference<?> |
CtTypeReference.getDeclaringType()
Gets the type that declares the referenced type.
|
CtTypeReference<?> |
CtFieldReference.getDeclaringType()
Gets the type in which the field is declared.
|
CtTypeReference<?> |
CtExecutableReference.getDeclaringType()
Gets the reference to the type that declares this executable.
|
CtTypeReference<?> |
CtTypeReference.getSuperclass() |
CtTypeReference<?> |
CtTypeReference.getTopLevelType()
Returns this, or top level type of this, if this is an inner type
|
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() |
CtTypeReference<T> |
CtTypeReference.setSimplyQualified(boolean isSimplyQualified) |
CtTypeReference<?> |
CtTypeReference.unbox()
Returns the primitive type for a boxing type (unchanged if the type does
not correspond to a boxing type).
|
Modifier and Type | Method and Description |
---|---|
java.util.List<CtTypeReference<?>> |
CtActualTypeContainer.getActualTypeArguments()
Gets the type arguments.
|
java.util.List<CtTypeReference<?>> |
CtIntersectionTypeReference.getBounds()
Gets the bounds of the intersection type.
|
java.util.List<CtTypeReference<?>> |
CtExecutableReference.getParameters()
Gets parameters of the executable.
|
java.util.Set<CtTypeReference<?>> |
CtTypeReference.getSuperInterfaces() |
Modifier and Type | Method and Description |
---|---|
<T extends CtActualTypeContainer> |
CtActualTypeContainer.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)
Adds a type argument.
|
<C extends CtIntersectionTypeReference> |
CtIntersectionTypeReference.addBound(CtTypeReference<?> bound)
Adds a bound.
|
boolean |
CtTypeReference.canAccess(CtTypeReference<?> type)
Checks visibility based on public, protected, package protected and private modifiers of type
|
<S extends T> |
CtExecutableReference.getOverridingExecutable(CtTypeReference<?> subType)
Gets an overriding executable for this executable from a given subtype,
if exists.
|
boolean |
CtActualTypeContainer.removeActualTypeArgument(CtTypeReference<?> actualTypeArgument)
Removes a type argument.
|
boolean |
CtIntersectionTypeReference.removeBound(CtTypeReference<?> bound)
Removes a bound.
|
<T extends CtWildcardReference> |
CtWildcardReference.setBoundingType(CtTypeReference<?> superType)
Sets the
extends clause of the type parameter. |
<C extends CtArrayTypeReference<T>> |
CtArrayTypeReference.setComponentType(CtTypeReference<?> componentType)
Sets the type of the elements contained in this array.
|
<C extends CtExecutableReference<T>> |
CtExecutableReference.setDeclaringType(CtTypeReference<?> declaringType)
Sets the declaring type.
|
<C extends CtFieldReference<T>> |
CtFieldReference.setDeclaringType(CtTypeReference<?> declaringType)
Sets the type in which the field is declared.
|
<C extends CtTypeReference<T>> |
CtTypeReference.setDeclaringType(CtTypeReference<?> type)
Sets the reference to the declaring type.
|
<C extends CtExecutableReference<T>> |
CtExecutableReference.setType(CtTypeReference<T> type)
Sets the type of the variable.
|
<C extends CtVariableReference<T>> |
CtVariableReference.setType(CtTypeReference<T> type)
Sets the type of the variable.
|
CtTypeMemberWildcardImportReference |
CtTypeMemberWildcardImportReference.setTypeReference(CtTypeReference<?> typeReference) |
Modifier and Type | Method and Description |
---|---|
<T extends CtActualTypeContainer> |
CtActualTypeContainer.setActualTypeArguments(java.util.List<? extends CtTypeReference<?>> actualTypeArguments)
Sets the type arguments.
|
<T extends CtActualTypeContainer> |
CtTypeParameterReference.setActualTypeArguments(java.util.List<? extends CtTypeReference<?>> actualTypeArguments) |
<C extends CtIntersectionTypeReference> |
CtIntersectionTypeReference.setBounds(java.util.List<CtTypeReference<?>> bounds)
Sets the bounds of the intersection type.
|
<C extends CtExecutableReference<T>> |
CtExecutableReference.setParameters(java.util.List<CtTypeReference<?>> parameters)
Sets parameters of the executable.
|
Modifier and Type | Field and Description |
---|---|
protected CtTypeReference<?> |
ImportScannerImpl.targetType |
Modifier and Type | Field and Description |
---|---|
protected java.util.Map<java.lang.String,CtTypeReference<?>> |
ImportScannerImpl.classImports |
Modifier and Type | Method and Description |
---|---|
CtTypeReference<?> |
PrintingContext.getCurrentTypeReference() |
Modifier and Type | Method and Description |
---|---|
protected boolean |
ImportScannerImpl.addClassImport(CtTypeReference<?> ref)
Adds a type to the classImports.
|
protected boolean |
ImportScannerImpl.classNamePresentInJavaLang(CtTypeReference<?> ref) |
protected void |
ImportCleaner.handleTypeReference(CtTypeReference<?> reference,
ImportCleaner.Context context,
CtRole role) |
protected void |
ForceImportProcessor.handleTypeReference(CtTypeReference<?> reference,
LexicalScope nameScope,
CtRole role) |
protected void |
ForceFullyQualifiedProcessor.handleTypeReference(CtTypeReference<?> reference,
LexicalScope nameScope,
CtRole role) |
protected void |
ImportConflictDetector.handleTypeReference(CtTypeReference<?> ref,
LexicalScope nameScope,
CtRole role) |
protected boolean |
ImportScannerImpl.isImportedInClassImports(CtTypeReference<?> ref) |
boolean |
PrintingContext.isInCurrentScope(CtTypeReference<?> typeRef) |
protected boolean |
ForceFullyQualifiedProcessor.isTypeReferenceToEnclosingType(LexicalScope nameScope,
CtTypeReference<?> reference) |
<T> void |
CtAbstractVisitor.visitCtTypeReference(CtTypeReference<T> reference) |
<T> void |
CtVisitor.visitCtTypeReference(CtTypeReference<T> reference)
Visits a reference to a type.
|
<T> void |
CtBiScannerDefault.visitCtTypeReference(CtTypeReference<T> reference) |
<T> void |
DefaultJavaPrettyPrinter.visitCtTypeReference(CtTypeReference<T> ref) |
<T> void |
CtInheritanceScanner.visitCtTypeReference(CtTypeReference<T> e) |
<T> void |
CtScanner.visitCtTypeReference(CtTypeReference<T> reference) |
<T> void |
ImportScannerImpl.visitCtTypeReference(CtTypeReference<T> reference) |
<T> void |
CtAbstractImportVisitor.visitTypeImport(CtTypeReference<T> typeReference) |
<T> void |
CtImportVisitor.visitTypeImport(CtTypeReference<T> typeReference)
Called for import like:
import apackage.Type; |
Modifier and Type | Method and Description |
---|---|
protected void |
SuperInheritanceHierarchyFunction.sendResult(CtTypeReference<?> typeRef,
CtConsumer<java.lang.Object> outputConsumer) |
protected void |
SuperInheritanceHierarchyFunction.visitSuperClasses(CtTypeReference<?> superTypeRef,
CtConsumer<java.lang.Object> outputConsumer,
boolean includingInterfaces)
calls `outputConsumer.accept(superClass)` for all super classes of superType.
|
protected void |
SuperInheritanceHierarchyFunction.visitSuperInterfaces(CtTypeReference<?> type,
CtConsumer<java.lang.Object> outputConsumer)
calls `outputConsumer.accept(interface)` for all superInterfaces of type recursively.
|
Constructor and Description |
---|
LambdaFilter(CtTypeReference<?> iface)
Matches all lambdas implementing `iface`
Use
LambdaFilter.addImplementingInterface(CtTypeInformation) to define set of interfaces whose lambdas it is search for |
SubtypeFilter(CtTypeReference<?> superType) |
Modifier and Type | Method and Description |
---|---|
<T> CtTypeReference<T> |
DefaultCoreFactory.createTypeReference() |
Modifier and Type | Method and Description |
---|---|
static CtStatement |
SnippetCompilationHelper.compileStatement(CtCodeSnippetStatement st,
CtTypeReference returnType) |
Modifier and Type | Method and Description |
---|---|
<T> CtTypeReference<T> |
ReferenceBuilder.getTypeReference(java.lang.String name)
Try to build a CtTypeReference from a simple name with specified generic types but
returns null if the name doesn't correspond to a type (not start by an upper case).
|
Modifier and Type | Method and Description |
---|---|
CtTypeReference<A> |
CtTypeAccessImpl.getAccessedType() |
CtTypeReference<T> |
CtVariableAccessImpl.getType() |
CtTypeReference<T> |
CtExpressionImpl.getType() |
CtTypeReference<T> |
CtCatchVariableImpl.getType() |
CtTypeReference<java.lang.Void> |
CtTypeAccessImpl.getType() |
CtTypeReference<T> |
CtInvocationImpl.getType() |
CtTypeReference<T> |
CtConstructorCallImpl.getType() |
CtTypeReference<T> |
CtAssignmentImpl.getType() |
CtTypeReference<T> |
CtLocalVariableImpl.getType() |
Modifier and Type | Method and Description |
---|---|
java.util.List<CtTypeReference<?>> |
CtInvocationImpl.getActualTypeArguments() |
java.util.List<CtTypeReference<?>> |
CtConstructorCallImpl.getActualTypeArguments() |
java.util.List<CtTypeReference<?>> |
CtCatchVariableImpl.getMultiTypes() |
java.util.Set<CtTypeReference<? extends java.lang.Throwable>> |
CtLambdaImpl.getThrownTypes() |
java.util.List<CtTypeReference<?>> |
CtExpressionImpl.getTypeCasts() |
java.util.List<CtTypeReference<?>> |
CtAssignmentImpl.getTypeCasts() |
Modifier and Type | Method and Description |
---|---|
<T extends CtActualTypeContainer> |
CtInvocationImpl.addActualTypeArgument(CtTypeReference<?> actualTypeArgument) |
<T extends CtActualTypeContainer> |
CtConstructorCallImpl.addActualTypeArgument(CtTypeReference<?> actualTypeArgument) |
<T extends CtMultiTypedElement> |
CtCatchVariableImpl.addMultiType(CtTypeReference<?> type) |
<C extends CtExecutable<T>> |
CtLambdaImpl.addThrownType(CtTypeReference<? extends java.lang.Throwable> throwType) |
<C extends CtExpression<T>> |
CtExpressionImpl.addTypeCast(CtTypeReference<?> type) |
<C extends CtExpression<T>> |
CtAssignmentImpl.addTypeCast(CtTypeReference<?> type) |
boolean |
CtInvocationImpl.removeActualTypeArgument(CtTypeReference<?> actualTypeArgument) |
boolean |
CtConstructorCallImpl.removeActualTypeArgument(CtTypeReference<?> actualTypeArgument) |
boolean |
CtCatchVariableImpl.removeMultiType(CtTypeReference<?> ref) |
boolean |
CtLambdaImpl.removeThrownType(CtTypeReference<? extends java.lang.Throwable> throwType) |
<C extends CtTypeAccess<A>> |
CtTypeAccessImpl.setAccessedType(CtTypeReference<A> accessedType) |
<C extends CtTypedElement> |
CtVariableAccessImpl.setType(CtTypeReference<T> type) |
<C extends CtTypedElement> |
CtExpressionImpl.setType(CtTypeReference<T> type) |
<C extends CtTypedElement> |
CtCatchVariableImpl.setType(CtTypeReference<T> type) |
<C extends CtTypedElement> |
CtInvocationImpl.setType(CtTypeReference<T> type) |
<C extends CtTypedElement> |
CtConstructorCallImpl.setType(CtTypeReference<T> type) |
<C extends CtTypedElement> |
CtAssignmentImpl.setType(CtTypeReference<T> type) |
<C extends CtTypedElement> |
CtLocalVariableImpl.setType(CtTypeReference<T> type) |
<C extends CtTypedElement> |
CtTypeAccessImpl.setType(CtTypeReference<java.lang.Void> type) |
Modifier and Type | Method and Description |
---|---|
<T extends CtActualTypeContainer> |
CtInvocationImpl.setActualTypeArguments(java.util.List<? extends CtTypeReference<?>> actualTypeArguments) |
<T extends CtActualTypeContainer> |
CtConstructorCallImpl.setActualTypeArguments(java.util.List<? extends CtTypeReference<?>> actualTypeArguments) |
<T extends CtMultiTypedElement> |
CtCatchVariableImpl.setMultiTypes(java.util.List<CtTypeReference<?>> types) |
<C extends CtExecutable<T>> |
CtLambdaImpl.setThrownTypes(java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes) |
<C extends CtExpression<T>> |
CtExpressionImpl.setTypeCasts(java.util.List<CtTypeReference<?>> casts) |
<C extends CtExpression<T>> |
CtAssignmentImpl.setTypeCasts(java.util.List<CtTypeReference<?>> casts) |
Modifier and Type | Method and Description |
---|---|
CtTypeReference<A> |
CtAnnotationImpl.getAnnotationType() |
CtTypeReference<T> |
CtTypeImpl.getReference() |
CtTypeReference |
CtUsedServiceImpl.getServiceType() |
CtTypeReference |
CtProvidedServiceImpl.getServiceType() |
CtTypeReference<?> |
CtAnnotationTypeImpl.getSuperclass() |
CtTypeReference<?> |
CtTypeParameterImpl.getSuperclass() |
CtTypeReference<?> |
CtTypeImpl.getSuperclass() |
CtTypeReference<?> |
CtEnumImpl.getSuperclass() |
CtTypeReference<?> |
CtClassImpl.getSuperclass() |
CtTypeReference<T> |
InvisibleArrayConstructorImpl.getType() |
CtTypeReference<T> |
CtMethodImpl.getType() |
CtTypeReference<java.lang.Void> |
CtAnonymousExecutableImpl.getType() |
CtTypeReference<T> |
CtParameterImpl.getType() |
CtTypeReference<T> |
CtFieldImpl.getType() |
CtTypeReference<T> |
CtConstructorImpl.getType() |
CtTypeReference<?> |
CtTypeParameterImpl.getTypeErasure() |
CtTypeReference<?> |
CtTypeImpl.getTypeErasure() |
Modifier and Type | Method and Description |
---|---|
java.util.List<CtTypeReference<?>> |
CtCompilationUnitImpl.getDeclaredTypeReferences() |
java.util.List<CtTypeReference> |
CtProvidedServiceImpl.getImplementationTypes() |
java.util.Set<CtTypeReference<?>> |
CtElementImpl.getReferencedTypes() |
java.util.Set<CtTypeReference<?>> |
CtAnnotationTypeImpl.getSuperInterfaces() |
java.util.Set<CtTypeReference<?>> |
CtTypeParameterImpl.getSuperInterfaces() |
java.util.Set<CtTypeReference<?>> |
CtTypeImpl.getSuperInterfaces() |
java.util.Set<CtTypeReference<? extends java.lang.Throwable>> |
CtAnnotationMethodImpl.getThrownTypes() |
java.util.Set<CtTypeReference<? extends java.lang.Throwable>> |
CtExecutableImpl.getThrownTypes() |
java.util.Set<CtTypeReference<? extends java.lang.Throwable>> |
CtAnonymousExecutableImpl.getThrownTypes() |
java.util.List<CtTypeReference<?>> |
CtAnnotationImpl.getTypeCasts() |
java.util.Set<CtTypeReference<?>> |
CtTypeImpl.getUsedTypes(boolean includeSamePackage) |
Modifier and Type | Method and Description |
---|---|
CtCompilationUnitImpl |
CtCompilationUnitImpl.addDeclaredTypeReference(CtTypeReference<?> type) |
<T extends CtProvidedService> |
CtProvidedServiceImpl.addImplementationType(CtTypeReference usedType) |
<S,C extends CtType<java.lang.Object>> |
CtTypeParameterImpl.addSuperInterface(CtTypeReference<S> interfac) |
<S,C extends CtType<T>> |
CtTypeImpl.addSuperInterface(CtTypeReference<S> interfac) |
CtExecutable |
CtAnonymousExecutableImpl.addThrownType(CtTypeReference throwType) |
<T extends CtExecutable<R>> |
CtExecutableImpl.addThrownType(CtTypeReference<? extends java.lang.Throwable> throwType) |
<A extends java.lang.annotation.Annotation> |
CtElementImpl.getAnnotation(CtTypeReference<A> annotationType) |
CtConstructor<T> |
CtClassImpl.getConstructor(CtTypeReference<?>... parameterTypes) |
<R> CtMethod<R> |
CtTypeParameterImpl.getMethod(CtTypeReference<R> returnType,
java.lang.String name,
CtTypeReference<?>... parameterTypes) |
<R> CtMethod<R> |
CtTypeParameterImpl.getMethod(CtTypeReference<R> returnType,
java.lang.String name,
CtTypeReference<?>... parameterTypes) |
<R> CtMethod<R> |
CtTypeImpl.getMethod(CtTypeReference<R> returnType,
java.lang.String name,
CtTypeReference<?>... parameterTypes) |
<R> CtMethod<R> |
CtTypeImpl.getMethod(CtTypeReference<R> returnType,
java.lang.String name,
CtTypeReference<?>... parameterTypes) |
<R> CtMethod<R> |
CtEnumImpl.getMethod(CtTypeReference<R> returnType,
java.lang.String name,
CtTypeReference<?>... parameterTypes) |
<R> CtMethod<R> |
CtEnumImpl.getMethod(CtTypeReference<R> returnType,
java.lang.String name,
CtTypeReference<?>... parameterTypes) |
<R> CtMethod<R> |
CtTypeParameterImpl.getMethod(java.lang.String name,
CtTypeReference<?>... parameterTypes) |
<R> CtMethod<R> |
CtTypeImpl.getMethod(java.lang.String name,
CtTypeReference<?>... parameterTypes) |
<R> CtMethod<R> |
CtEnumImpl.getMethod(java.lang.String name,
CtTypeReference<?>... parameterTypes) |
java.util.Set<CtMethod<?>> |
CtTypeParameterImpl.getMethodsAnnotatedWith(CtTypeReference<?>... annotationTypes) |
java.util.Set<CtMethod<?>> |
CtTypeImpl.getMethodsAnnotatedWith(CtTypeReference<?>... annotationTypes) |
protected boolean |
CtTypeImpl.hasSameParameters(CtExecutable<?> candidate,
CtTypeReference<?>... parameterTypes) |
boolean |
CtInterfaceImpl.isSubtypeOf(CtTypeReference<?> type) |
boolean |
CtAnnotationTypeImpl.isSubtypeOf(CtTypeReference<?> type) |
boolean |
CtTypeParameterImpl.isSubtypeOf(CtTypeReference<?> superTypeRef) |
boolean |
CtEnumImpl.isSubtypeOf(CtTypeReference<?> type) |
boolean |
CtClassImpl.isSubtypeOf(CtTypeReference<?> type) |
<S> boolean |
CtTypeParameterImpl.removeSuperInterface(CtTypeReference<S> interfac) |
<S> boolean |
CtTypeImpl.removeSuperInterface(CtTypeReference<S> interfac) |
boolean |
CtAnonymousExecutableImpl.removeThrownType(CtTypeReference throwType) |
boolean |
CtExecutableImpl.removeThrownType(CtTypeReference<? extends java.lang.Throwable> throwType) |
<T extends CtAnnotation<A>> |
CtAnnotationImpl.setAnnotationType(CtTypeReference<? extends java.lang.annotation.Annotation> annotationType) |
<T extends CtProvidedService> |
CtProvidedServiceImpl.setServiceType(CtTypeReference providingType) |
<T extends CtUsedService> |
CtUsedServiceImpl.setServiceType(CtTypeReference usedService) |
<C extends CtType<java.lang.Object>> |
CtTypeParameterImpl.setSuperclass(CtTypeReference<?> superClass) |
<C extends CtType<T>> |
CtInterfaceImpl.setSuperclass(CtTypeReference<?> superClass) |
<C extends CtType<T>> |
CtAnnotationTypeImpl.setSuperclass(CtTypeReference<?> superClass) |
<C extends CtType<T>> |
CtTypeImpl.setSuperclass(CtTypeReference<?> superClass) |
<C extends CtType<T>> |
CtEnumImpl.setSuperclass(CtTypeReference<?> superClass) |
<C extends CtType<T>> |
CtClassImpl.setSuperclass(CtTypeReference<?> superClass) |
<C extends CtTypedElement> |
InvisibleArrayConstructorImpl.setType(CtTypeReference<T> type) |
<C extends CtTypedElement> |
CtMethodImpl.setType(CtTypeReference<T> type) |
<C extends CtTypedElement> |
CtParameterImpl.setType(CtTypeReference<T> type) |
<C extends CtTypedElement> |
CtFieldImpl.setType(CtTypeReference<T> type) |
<C extends CtTypedElement> |
CtConstructorImpl.setType(CtTypeReference<T> type) |
<C extends CtTypedElement> |
CtAnonymousExecutableImpl.setType(CtTypeReference<java.lang.Void> type) |
Modifier and Type | Method and Description |
---|---|
CtCompilationUnitImpl |
CtCompilationUnitImpl.setDeclaredTypeReferences(java.util.List<CtTypeReference<?>> types) |
<T extends CtProvidedService> |
CtProvidedServiceImpl.setImplementationTypes(java.util.List<CtTypeReference> usedTypes) |
<C extends CtType<java.lang.Object>> |
CtTypeParameterImpl.setSuperInterfaces(java.util.Set<CtTypeReference<?>> interfaces) |
<C extends CtType<T>> |
CtAnnotationTypeImpl.setSuperInterfaces(java.util.Set<CtTypeReference<?>> interfaces) |
<C extends CtType<T>> |
CtTypeImpl.setSuperInterfaces(java.util.Set<CtTypeReference<?>> interfaces) |
<T extends CtExecutable<R>> |
CtExecutableImpl.setThrownTypes(java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes) |
<U extends CtExecutable<T>> |
CtAnnotationMethodImpl.setThrownTypes(java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes) |
<C extends CtExpression<A>> |
CtAnnotationImpl.setTypeCasts(java.util.List<CtTypeReference<?>> casts) |
Modifier and Type | Class and Description |
---|---|
class |
CtArrayTypeReferenceImpl<T> |
class |
CtIntersectionTypeReferenceImpl<T> |
class |
CtTypeParameterReferenceImpl |
class |
CtTypeReferenceImpl<T> |
class |
CtWildcardReferenceImpl |
Modifier and Type | Method and Description |
---|---|
<C extends CtTypeReference<T>> |
CtTypeReferenceImpl.setDeclaringType(CtTypeReference<?> declaringType) |
<C extends CtTypeReference<T>> |
CtTypeReferenceImpl.setPackage(CtPackageReference pack) |
Modifier and Type | Method and Description |
---|---|
CtTypeReference<?> |
CtTypeReferenceImpl.box() |
CtTypeReference<T> |
CtTypeReferenceImpl.clone() |
CtTypeReference<?> |
CtTypeReferenceImpl.getAccessType() |
CtTypeReference<?> |
CtArrayTypeReferenceImpl.getArrayType() |
CtTypeReference<?> |
CtWildcardReferenceImpl.getBoundingType() |
CtTypeReference<?> |
CtTypeParameterReferenceImpl.getBoundingType() |
CtTypeReference<?> |
CtArrayTypeReferenceImpl.getComponentType() |
CtTypeReference<?> |
CtTypeReferenceImpl.getDeclaringType() |
CtTypeReference<?> |
CtExecutableReferenceImpl.getDeclaringType() |
CtTypeReference<?> |
CtFieldReferenceImpl.getDeclaringType() |
CtTypeReference<?> |
CtTypeReferenceImpl.getSuperclass() |
CtTypeReference<?> |
CtTypeReferenceImpl.getTopLevelType() |
CtTypeReference<T> |
CtVariableReferenceImpl.getType() |
CtTypeReference<T> |
CtExecutableReferenceImpl.getType() |
CtTypeReference<?> |
CtTypeParameterReferenceImpl.getTypeErasure() |
CtTypeReference<?> |
CtTypeReferenceImpl.getTypeErasure() |
CtTypeReference<?> |
CtIntersectionTypeReferenceImpl.getTypeErasure() |
CtTypeReference<?> |
CtArrayTypeReferenceImpl.getTypeErasure() |
CtTypeReference<?> |
CtTypeMemberWildcardImportReferenceImpl.getTypeReference() |
CtTypeReference<?> |
CtTypeReferenceImpl.unbox() |
Modifier and Type | Method and Description |
---|---|
java.util.List<CtTypeReference<?>> |
CtTypeParameterReferenceImpl.getActualTypeArguments() |
java.util.List<CtTypeReference<?>> |
CtTypeReferenceImpl.getActualTypeArguments() |
java.util.List<CtTypeReference<?>> |
CtExecutableReferenceImpl.getActualTypeArguments() |
java.util.List<CtTypeReference<?>> |
CtIntersectionTypeReferenceImpl.getBounds() |
java.util.List<CtTypeReference<?>> |
CtExecutableReferenceImpl.getParameters() |
java.util.Set<CtTypeReference<?>> |
CtTypeReferenceImpl.getSuperInterfaces() |
Modifier and Type | Method and Description |
---|---|
<C extends CtActualTypeContainer> |
CtTypeParameterReferenceImpl.addActualTypeArgument(CtTypeReference<?> actualTypeArgument) |
<C extends CtActualTypeContainer> |
CtTypeReferenceImpl.addActualTypeArgument(CtTypeReference<?> actualTypeArgument) |
<C extends CtActualTypeContainer> |
CtExecutableReferenceImpl.addActualTypeArgument(CtTypeReference<?> actualTypeArgument) |
<C extends CtIntersectionTypeReference> |
CtIntersectionTypeReferenceImpl.addBound(CtTypeReference<?> bound) |
boolean |
CtTypeReferenceImpl.canAccess(CtTypeReference<?> type) |
<S extends T> |
CtExecutableReferenceImpl.getOverridingExecutable(CtTypeReference<?> subType) |
boolean |
CtTypeParameterReferenceImpl.isSubtypeOf(CtTypeReference<?> type) |
boolean |
CtTypeReferenceImpl.isSubtypeOf(CtTypeReference<?> type) |
boolean |
CtTypeParameterReferenceImpl.removeActualTypeArgument(CtTypeReference<?> actualTypeArgument) |
boolean |
CtTypeReferenceImpl.removeActualTypeArgument(CtTypeReference<?> actualTypeArgument) |
boolean |
CtExecutableReferenceImpl.removeActualTypeArgument(CtTypeReference<?> actualTypeArgument) |
boolean |
CtIntersectionTypeReferenceImpl.removeBound(CtTypeReference<?> bound) |
<T extends CtWildcardReference> |
CtWildcardReferenceImpl.setBoundingType(CtTypeReference<?> superType) |
<C extends CtArrayTypeReference<T>> |
CtArrayTypeReferenceImpl.setComponentType(CtTypeReference<?> componentType) |
<C extends CtExecutableReference<T>> |
CtExecutableReferenceImpl.setDeclaringType(CtTypeReference<?> declaringType) |
<C extends CtFieldReference<T>> |
CtFieldReferenceImpl.setDeclaringType(CtTypeReference<?> declaringType) |
<C extends CtTypeReference<T>> |
CtTypeReferenceImpl.setDeclaringType(CtTypeReference<?> declaringType) |
<C extends CtExecutableReference<T>> |
CtExecutableReferenceImpl.setType(CtTypeReference<T> type) |
<C extends CtVariableReference<T>> |
CtVariableReferenceImpl.setType(CtTypeReference<T> type) |
CtTypeMemberWildcardImportReferenceImpl |
CtTypeMemberWildcardImportReferenceImpl.setTypeReference(CtTypeReference<?> typeReference) |
Modifier and Type | Method and Description |
---|---|
<C extends CtActualTypeContainer> |
CtTypeParameterReferenceImpl.setActualTypeArguments(java.util.List<? extends CtTypeReference<?>> actualTypeArguments) |
<C extends CtActualTypeContainer> |
CtTypeReferenceImpl.setActualTypeArguments(java.util.List<? extends CtTypeReference<?>> actualTypeArguments) |
<C extends CtActualTypeContainer> |
CtExecutableReferenceImpl.setActualTypeArguments(java.util.List<? extends CtTypeReference<?>> actualTypeArguments) |
<C extends CtIntersectionTypeReference> |
CtIntersectionTypeReferenceImpl.setBounds(java.util.List<CtTypeReference<?>> bounds) |
<C extends CtExecutableReference<T>> |
CtExecutableReferenceImpl.setParameters(java.util.List<CtTypeReference<?>> parameters) |
Modifier and Type | Method and Description |
---|---|
CtTypeReference<?> |
GenericTypeAdapter.adaptType(CtTypeInformation type)
adapts `type` to the
CtTypeReference
of the scope of this GenericTypeAdapter
This mapping function is able to resolve CtTypeParameter of:A) input type or any super class or any enclosing class of input type or it's super class B) super interfaces of input type or super interfaces of it's super classes. The type reference is adapted recursive including all it's actual type arguments and bounds. |
protected CtTypeReference<?> |
ClassTypingContext.adaptTypeParameter(CtTypeParameter typeParam)
adapts `typeParam` to the
CtTypeReference
of scope of this ClassTypingContext
In can be CtTypeParameterReference again - depending actual type arguments of this ClassTypingContext . |
protected CtTypeReference<?> |
MethodTypingContext.adaptTypeParameter(CtTypeParameter typeParam)
Adapts `typeParam` to the
CtTypeReference
of scope of this MethodTypingContext
In can be CtTypeParameterReference again - depending actual type arguments of this MethodTypingContext . |
Modifier and Type | Method and Description |
---|---|
java.util.Set<CtTypeReference<?>> |
TypeReferenceScanner.getReferences()
Returns the set of calculated references.
|
java.util.List<CtTypeReference<?>> |
ClassTypingContext.resolveActualTypeArgumentsOf(CtTypeReference<?> typeRef)
resolve actual type argument values of the provided type reference
|
Modifier and Type | Method and Description |
---|---|
protected ClassTypingContext |
ClassTypingContext.createEnclosingHierarchy(CtTypeReference<?> enclosingTypeRef)
might be used to create custom chain of super type hierarchies
|
boolean |
ClassTypingContext.isSubtypeOf(CtTypeReference<?> superTypeRef)
detects if `superTypeRef` is a super type of the type or type reference,
which was send to constructor of this instance.
|
java.util.List<CtTypeReference<?>> |
ClassTypingContext.resolveActualTypeArgumentsOf(CtTypeReference<?> typeRef)
resolve actual type argument values of the provided type reference
|
<T> void |
SignaturePrinter.visitCtTypeReference(CtTypeReference<T> reference) |
<T> void |
TypeReferenceScanner.visitCtTypeReference(CtTypeReference<T> reference) |
Constructor and Description |
---|
ClassTypingContext(CtTypeReference<?> typeReference) |
Constructor and Description |
---|
TypeReferenceScanner(java.util.HashSet<CtTypeReference<?>> references)
Constructor.
|
Modifier and Type | Method and Description |
---|---|
<T> void |
CloneBuilder.visitCtTypeReference(CtTypeReference<T> e) |
<T> void |
CloneVisitor.visitCtTypeReference(CtTypeReference<T> reference) |
Modifier and Type | Method and Description |
---|---|
void |
TypeRuntimeBuilderContext.addTypeReference(CtRole role,
CtTypeReference<?> typeReference) |
void |
AnnotationRuntimeBuilderContext.addTypeReference(CtRole role,
CtTypeReference<?> typeReference) |
void |
RuntimeBuilderContext.addTypeReference(CtRole role,
CtTypeReference<?> ctTypeReference) |
void |
ExecutableRuntimeBuilderContext.addTypeReference(CtRole role,
CtTypeReference<?> typeReference) |
void |
TypeReferenceRuntimeBuilderContext.addTypeReference(CtRole role,
CtTypeReference<?> ctTypeReference) |
void |
VariableRuntimeBuilderContext.addTypeReference(CtRole role,
CtTypeReference<?> ctTypeReference) |
Constructor and Description |
---|
TypeReferenceRuntimeBuilderContext(java.lang.reflect.Type type,
CtTypeReference<?> typeReference) |
Modifier and Type | Method and Description |
---|---|
<T> void |
ReplacementVisitor.visitCtTypeReference(CtTypeReference<T> reference) |
Modifier and Type | Method and Description |
---|---|
static void |
Substitution.redirectTypeReferences(CtElement element,
CtTypeReference<?> source,
CtTypeReference<?> target)
A helper method that recursively redirects all the type references from a
source type to a target type in the given element.
|
static void |
Substitution.redirectTypeReferences(CtElement element,
CtTypeReference<?> source,
CtTypeReference<?> target)
A helper method that recursively redirects all the type references from a
source type to a target type in the given element.
|
static CtBlock<?> |
Substitution.substituteMethodBody(CtClass<?> targetClass,
Template<?> template,
java.lang.String executableName,
CtTypeReference<?>... parameterTypes)
Gets a body from a template executable with all the template parameters
substituted.
|
static CtStatement |
Substitution.substituteStatement(CtClass<?> targetClass,
Template<?> template,
int statementIndex,
java.lang.String executableName,
CtTypeReference<?>... parameterTypes)
Gets a statement from a template executable with all the template
parameters substituted.
|
Copyright © 2007–2021 Inria. All rights reserved.