jmlparser-core/com.github.javaparser.ast.body/ConstructorDeclaration

ConstructorDeclaration

A constructor declaration: class X { X() { } } where X(){} is the constructor declaration.

All annotations preceding the name will be set on this object, not on the class. JavaParser doesn't know if it they are applicable to the method or the class.

Author

Julio Vilmar Gesser

Constructors

ConstructorDeclaration

constructor()

constructor(name: String)

constructor(modifiers: NodeList<Modifier>, name: String)

constructor(modifiers: NodeList<Modifier>, annotations: NodeList<AnnotationExpr>, typeParameters: NodeList<TypeParameter>, name: SimpleName, parameters: NodeList<Parameter>, thrownExceptions: NodeList<ReferenceType>, body: BlockStmt)

constructor(range: TokenRange, modifiers: NodeList<Modifier>, annotations: NodeList<AnnotationExpr>, list: NodeList<TypeParameter>, name: SimpleName, parameters: NodeList<Parameter>, thrownExceptions: NodeList<ReferenceType>, stmt: BlockStmt, receiverParameter: ReceiverParameter)

constructor(tokenRange: TokenRange, modifiers: NodeList<Modifier>, annotations: NodeList<AnnotationExpr>, typeParameters: NodeList<TypeParameter>, name: SimpleName, parameters: NodeList<Parameter>, thrownExceptions: NodeList<ReferenceType>, body: BlockStmt, receiverParameter: ReceiverParameter, contracts: NodeList<JmlContract>)

This constructor is used by the parser and is considered private.

Properties

ABSOLUTE_BEGIN_LINE

val ~~ABSOLUTE_BEGIN_LINE~~: Int = -1

ABSOLUTE_END_LINE

val ~~ABSOLUTE_END_LINE~~: Int = -2

annotations

open var annotations: NodeList<AnnotationExpr>

comment

private open var comment: Comment

contracts

open var contracts: NodeList<JmlContract>

LINE_SEPARATOR_KEY

val LINE_SEPARATOR_KEY: DataKey<LineSeparator>

modifiers

open var modifiers: NodeList<Modifier>

name

open var name: SimpleName

NODE_BY_BEGIN_POSITION

open var NODE_BY_BEGIN_POSITION: Comparator<NodeWithRange<out Any>>

This can be used to sort nodes on position.

parameters

open var parameters: NodeList<Parameter>

parentNode

private open var parentNode: Node

parsed

open var parsed: Node.Parsedness

PRINTER_KEY

val PRINTER_KEY: DataKey<Printer>

range

private open var range: Range

SYMBOL_RESOLVER_KEY

val SYMBOL_RESOLVER_KEY: DataKey<SymbolResolver>

thrownExceptions

open var thrownExceptions: NodeList<ReferenceType>

tokenRange

private open var tokenRange: TokenRange

typeParameters

open var typeParameters: NodeList<TypeParameter>

Functions

open fun <R, A> accept(v: GenericVisitor<R, A>, arg: A): R

open fun <A> accept(v: VoidVisitor<A>, arg: A)

Accept method for visitor support.

addAndGetAnnotation

open fun addAndGetAnnotation(clazz: Class<out Annotation>): NormalAnnotationExpr

Annotates this node and automatically add the import

open fun addAndGetAnnotation(name: String): NormalAnnotationExpr

Annotates this

addAndGetParameter

open fun addAndGetParameter(parameter: Parameter): Parameter

open fun addAndGetParameter(type: Type, name: String): Parameter

open fun addAndGetParameter(paramClass: Class<out Any>, name: String): Parameter

open fun addAndGetParameter(className: String, name: String): Parameter

Remember to import the class in the compilation unit yourself

addAnnotation

open fun addAnnotation(element: AnnotationExpr): N

open fun addAnnotation(clazz: Class<out Annotation>): N

Annotates this node and automatically add the import

open fun addAnnotation(name: String): N

Annotates this

addContract

open fun addContract(contracts: JmlContract)

addContracts

open fun addContracts(contracts: Array<JmlContract>)

addMarkerAnnotation

open fun addMarkerAnnotation(clazz: Class<out Annotation>): N

Annotates this with a marker annotation and automatically add the import

open fun addMarkerAnnotation(name: String): N

Annotates this with a marker annotation

addModifier

open fun addModifier(newModifiers: Array<Modifier.Keyword>): N

addOrphanComment

open fun addOrphanComment(comment: Comment)

addParameter

open fun addParameter(parameter: Parameter): N

open fun addParameter(type: Type, name: String): N

open fun addParameter(paramClass: Class<out Any>, name: String): N

open fun addParameter(className: String, name: String): N

Remember to import the class in the compilation unit yourself

addSingleMemberAnnotation

open fun addSingleMemberAnnotation(clazz: Class<out Annotation>, expression: Expression): N

open fun addSingleMemberAnnotation(name: String, expression: Expression): N

open fun addSingleMemberAnnotation(name: String, value: String): N

Annotates this with a single member annotation

open fun addSingleMemberAnnotation(clazz: Class<out Annotation>, value: String): N

Annotates this with a single member annotation and automatically add the import

addThrownException

open fun addThrownException(throwType: ReferenceType): N

Adds this type to the throws clause

open fun addThrownException(clazz: Class<out Throwable>): N

Adds this class to the throws clause

addTypeParameter

open fun addTypeParameter(typeParameter: TypeParameter): N

open fun addTypeParameter(typeParameter: String): N

Adds a type parameter like X extends Serializable

annotations

@NonNull

open fun annotations(): @NonNull NodeList<AnnotationExpr>

asAnnotationDeclaration

open fun asAnnotationDeclaration(): AnnotationDeclaration

asAnnotationMemberDeclaration

open fun asAnnotationMemberDeclaration(): AnnotationMemberDeclaration

asCallableDeclaration

open fun asCallableDeclaration(): CallableDeclaration

asClassOrInterfaceDeclaration

open fun asClassOrInterfaceDeclaration(): ClassOrInterfaceDeclaration

asCompactConstructorDeclaration

open fun asCompactConstructorDeclaration(): CompactConstructorDeclaration

asConstructorDeclaration

open fun asConstructorDeclaration(): ConstructorDeclaration

asEnumConstantDeclaration

open fun asEnumConstantDeclaration(): EnumConstantDeclaration

asEnumDeclaration

open fun asEnumDeclaration(): EnumDeclaration

asFieldDeclaration

open fun asFieldDeclaration(): FieldDeclaration

asInitializerDeclaration

open fun asInitializerDeclaration(): InitializerDeclaration

asJmlClassAccessibleDeclaration

open fun asJmlClassAccessibleDeclaration(): JmlClassAccessibleDeclaration

asJmlClassExprDeclaration

open fun asJmlClassExprDeclaration(): JmlClassExprDeclaration

asJmlClassLevelDeclaration

open fun asJmlClassLevelDeclaration(): JmlClassLevelDeclaration

asJmlDocDeclaration

open fun asJmlDocDeclaration(): JmlDocDeclaration

asJmlDocType

open fun asJmlDocType(): JmlDocType

asJmlFieldDeclaration

open fun asJmlFieldDeclaration(): JmlFieldDeclaration

asJmlMethodDeclaration

open fun asJmlMethodDeclaration(): JmlMethodDeclaration

asJmlRepresentsDeclaration

open fun asJmlRepresentsDeclaration(): JmlRepresentsDeclaration

asMethodDeclaration

open fun asMethodDeclaration(): MethodDeclaration

asRecordDeclaration

open fun asRecordDeclaration(): RecordDeclaration

associatedSpecificationComments

@Nullable

open fun associatedSpecificationComments(): @Nullable NodeList<Comment>

asTypeDeclaration

open fun asTypeDeclaration(): TypeDeclaration

body

@Nullable

open fun body(): @Nullable BlockStmt

clone

open fun clone(): Node

open fun clone(): BodyDeclaration<out Any>

open fun clone(): ConstructorDeclaration

comment

@Nullable

open fun comment(): @Nullable Comment

containsData

open fun containsData(key: DataKey<out Any>): Boolean

containsWithin

open fun ~~containsWithin~~(other: Node): Boolean

containsWithinRange

open fun containsWithinRange(other: Node): Boolean

Checks whether the range of the given Node is contained within the range of this NodeWithRange.

contracts

@NonNull

open fun contracts(): @NonNull NodeList<JmlContract>

createBody

open fun createBody(): BlockStmt

equals

open fun equals(obj: Any): Boolean

findAll

open fun <T : Node?> findAll(nodeType: Class<T>): List<T>

Walks the AST with pre-order traversal, returning all nodes of type "nodeType".

open fun <T : Node?> findAll(nodeType: Class<T>, traversal: Node.TreeTraversal): List<T>

Walks the AST with specified traversal order, returning all nodes of type "nodeType".

open fun <T : Node?> findAll(nodeType: Class<T>, predicate: Predicate<T>): List<T>

Walks the AST with pre-order traversal, returning all nodes of type "nodeType" that match the predicate.

findAncestor

open fun <N> findAncestor(types: Array<Class<N>>): Optional<N>

Walks the parents of this node and returns the first node of type type, or empty() if none is found.

open fun <N> ~~findAncestor~~(type: Class<N>, predicate: Predicate<N>): Optional<N>

Walks the parents of this node and returns the first node of type type that matches predicate, or empty() if none is found.

open fun <N> findAncestor(predicate: Predicate<N>, types: Array<Class<N>>): Optional<N>

Walks the parents of this node and returns the first node that matches one of types types, or empty() if none is found.

findByRange

open fun findByRange(range: Range): Optional<Node>

findCompilationUnit

open fun findCompilationUnit(): Optional<CompilationUnit>

findData

open fun <M> findData(key: DataKey<M>): Optional<M>

Gets data for this node using the given key or returns an Optional.empty().

findFirst

open fun <N : Node?> findFirst(nodeType: Class<N>): Optional<N>

Walks the AST with pre-order traversal, returning the first node of type "nodeType" or empty() if none is found.

open fun <T> findFirst(traversal: Node.TreeTraversal, consumer: (Node) -> Optional<T>): Optional<T>

Walks the AST, applying the function for every node, with traversal algorithm "traversal".

open fun <N : Node?> findFirst(nodeType: Class<N>, predicate: Predicate<N>): Optional<N>

Walks the AST with pre-order traversal, returning the first node of type "nodeType" that matches "predicate" or empty() if none is found.

findRootNode

open fun findRootNode(): Node

Finds the root node of this AST by finding the topmost parent.

getAccessSpecifier

open fun getAccessSpecifier(): AccessSpecifier

getAllContainedComments

open fun getAllContainedComments(): List<Comment>

This is the list of Comment which are contained in the Node either because they are properly associated to one of its children or because they are floating around inside the Node

getAnnotation

open fun getAnnotation(i: Int): AnnotationExpr

getAnnotationByClass

open fun getAnnotationByClass(annotationClass: Class<out Annotation>): Optional<AnnotationExpr>

Try to find an annotation by its class

getAnnotationByName

open fun getAnnotationByName(annotationName: String): Optional<AnnotationExpr>

Try to find an annotation by its name

getAssociatedSpecificationComments

open fun getAssociatedSpecificationComments(): Optional<NodeList<Comment>>

This field is used by key to associated (JML) comments to this node.

getBegin

open fun getBegin(): Optional<Position>

The begin position of this node in the source file.

getBody

open fun getBody(): Optional<BlockStmt>

getChildNodes

open fun getChildNodes(): List<Node>

Contains all nodes that have this node set as their parent.

getChildNodesByType

open fun <N : Node?> ~~getChildNodesByType~~(clazz: Class<N>): List<N>

Recursively finds all nodes of a certain type.

getComment

abstract fun getComment(): Optional<Comment>

getData

open fun <M> getData(key: DataKey<M>): M

Gets data for this node using the given key.

getDataKeys

open fun getDataKeys(): Set<DataKey<out Any>>

This method was added to support the clone method.

getDeclarationAsString

open fun getDeclarationAsString(includingModifiers: Boolean, includingThrows: Boolean, includingParameterName: Boolean): String

The declaration returned has this schema: [accessSpecifier] className ([paramType [paramName]]) [throws exceptionsList]

open fun getDeclarationAsString(): String

As getDeclarationAsString including the modifiers, the throws clause and the parameters with both type and name.

open fun getDeclarationAsString(includingModifiers: Boolean, includingThrows: Boolean): String

As getDeclarationAsString including the parameters with both type and name.

getEnd

open fun getEnd(): Optional<Position>

The end position of this node in the source file.

getJavadoc

open fun getJavadoc(): Optional<Javadoc>

Gets the Javadoc for this node.

getJavadocComment

open fun getJavadocComment(): Optional<JavadocComment>

Gets the JavadocComment for this node.

getLineEndingStyle

open fun getLineEndingStyle(): LineSeparator

getLineEndingStyleOrDefault

open fun getLineEndingStyleOrDefault(defaultLineSeparator: LineSeparator): LineSeparator

getMetaModel

open fun getMetaModel(): NodeMetaModel

open fun getMetaModel(): BodyDeclarationMetaModel

open fun getMetaModel(): ConstructorDeclarationMetaModel

getNameAsExpression

open fun getNameAsExpression(): NameExpr

getNameAsString

open fun getNameAsString(): String

getNodesByType

open fun <N : Node?> ~~getNodesByType~~(clazz: Class<N>): List<N>

getOrphanComments

open fun getOrphanComments(): List<Comment>

This is a list of Comment which are inside the node and are not associated with any meaningful AST Node.

getParameter

open fun getParameter(i: Int): Parameter

getParameterByName

open fun getParameterByName(name: String): Optional<Parameter>

Try to find a Parameter by its name

getParameterByType

open fun getParameterByType(type: Class<out Any>): Optional<Parameter>

open fun getParameterByType(type: String): Optional<Parameter>

Try to find a Parameter by its type

getParentNode

open fun getParentNode(): Optional<Node>

Returns the parent node, or Optional.empty if no parent is set.

getParentNodeForChildren

open fun getParentNodeForChildren(): Node

Returns the parent node from the perspective of the children of this node.

getParentNodeOfType

open fun <T : Node?> getParentNodeOfType(clazz: Class<T>): Optional<T>

Finds the first parent of the given class.

getRange

open fun getRange(): Optional<Range>

getReceiverParameter

open fun getReceiverParameter(): Optional<ReceiverParameter>

getSignature

open fun getSignature(): CallableDeclaration.Signature

getSymbolResolver

open fun getSymbolResolver(): SymbolResolver

getThrownException

open fun getThrownException(i: Int): ReferenceType

getTokenRange

open fun getTokenRange(): Optional<TokenRange>

getTypeParameter

open fun getTypeParameter(i: Int): TypeParameter

hashCode

fun hashCode(): Int

hasJavaDocComment

open fun hasJavaDocComment(): Boolean

hasModifier

open fun hasModifier(modifier: Modifier.Keyword): Boolean

hasParametersOfType

open fun hasParametersOfType(paramTypes: Array<Class<out Any>>): Boolean

open fun hasParametersOfType(paramTypes: Array<String>): Boolean

Check if the parameters have certain types.

hasParentNode

open fun hasParentNode(): Boolean

Returns true if the parent has a parent

hasRange

open fun hasRange(): Boolean

hasScope

open fun hasScope(): Boolean

ifAnnotationDeclaration

open fun ifAnnotationDeclaration(action: Consumer<AnnotationDeclaration>)

ifAnnotationMemberDeclaration

open fun ifAnnotationMemberDeclaration(action: Consumer<AnnotationMemberDeclaration>)

ifCallableDeclaration

open fun ifCallableDeclaration(action: Consumer<CallableDeclaration>)

ifClassInvariantClause

open fun ifClassInvariantClause(action: Consumer<JmlClassExprDeclaration>)

ifClassOrInterfaceDeclaration

open fun ifClassOrInterfaceDeclaration(action: Consumer<ClassOrInterfaceDeclaration>)

ifCompactConstructorDeclaration

open fun ifCompactConstructorDeclaration(action: Consumer<CompactConstructorDeclaration>)

ifConstructorDeclaration

open fun ifConstructorDeclaration(action: Consumer<ConstructorDeclaration>)

ifEnumConstantDeclaration

open fun ifEnumConstantDeclaration(action: Consumer<EnumConstantDeclaration>)

ifEnumDeclaration

open fun ifEnumDeclaration(action: Consumer<EnumDeclaration>)

ifFieldDeclaration

open fun ifFieldDeclaration(action: Consumer<FieldDeclaration>)

ifInitializerDeclaration

open fun ifInitializerDeclaration(action: Consumer<InitializerDeclaration>)

ifJmlClassAccessibleDeclaration

open fun ifJmlClassAccessibleDeclaration(action: Consumer<JmlClassAccessibleDeclaration>)

ifJmlClassExprDeclaration

open fun ifJmlClassExprDeclaration(action: Consumer<JmlClassExprDeclaration>)

ifJmlClassLevelDeclaration

open fun ifJmlClassLevelDeclaration(action: Consumer<JmlClassLevelDeclaration>)

ifJmlDocDeclaration

open fun ifJmlDocDeclaration(action: Consumer<JmlDocDeclaration>)

ifJmlDocType

open fun ifJmlDocType(action: Consumer<JmlDocType>)

ifJmlFieldDeclaration

open fun ifJmlFieldDeclaration(action: Consumer<JmlFieldDeclaration>)

ifJmlMethodDeclaration

open fun ifJmlMethodDeclaration(action: Consumer<JmlMethodDeclaration>)

ifJmlRepresentsDeclaration

open fun ifJmlRepresentsDeclaration(action: Consumer<JmlRepresentsDeclaration>)

ifMethodDeclaration

open fun ifMethodDeclaration(action: Consumer<MethodDeclaration>)

ifRecordDeclaration

open fun ifRecordDeclaration(action: Consumer<RecordDeclaration>)

ifTypeDeclaration

open fun ifTypeDeclaration(action: Consumer<TypeDeclaration>)

isAbstract

open fun isAbstract(): Boolean

isAncestorOf

open fun isAncestorOf(descendant: Node): Boolean

Determines whether this node is an ancestor of the given node.

isAnnotationDeclaration

open fun isAnnotationDeclaration(): Boolean

isAnnotationMemberDeclaration

open fun isAnnotationMemberDeclaration(): Boolean

isAnnotationPresent

open fun isAnnotationPresent(annotationClass: Class<out Annotation>): Boolean

Check whether an annotation with this class is present on this element

open fun isAnnotationPresent(annotationName: String): Boolean

Check whether an annotation with this name is present on this element

isCallableDeclaration

open fun isCallableDeclaration(): Boolean

isClassOrInterfaceDeclaration

open fun isClassOrInterfaceDeclaration(): Boolean

isCompactConstructorDeclaration

open fun isCompactConstructorDeclaration(): Boolean

isConstructorDeclaration

open fun isConstructorDeclaration(): Boolean

isDescendantOf

open fun isDescendantOf(ancestor: Node): Boolean

Determines whether this HasParentNode node is a descendant of the given node.

isEnumConstantDeclaration

open fun isEnumConstantDeclaration(): Boolean

isEnumDeclaration

open fun isEnumDeclaration(): Boolean

isFieldDeclaration

open fun isFieldDeclaration(): Boolean

isFinal

open fun isFinal(): Boolean

isFixedArityMethod

open fun isFixedArityMethod(): Boolean

isGeneric

open fun isGeneric(): Boolean

isInitializerDeclaration

open fun isInitializerDeclaration(): Boolean

isJmlBodyDeclaration

open fun isJmlBodyDeclaration(): Boolean

isJmlClassAccessibleDeclaration

open fun isJmlClassAccessibleDeclaration(): Boolean

isJmlClassExprDeclaration

open fun isJmlClassExprDeclaration(): Boolean

isJmlClassLevelDeclaration

open fun isJmlClassLevelDeclaration(): Boolean

isJmlDocDeclaration

open fun isJmlDocDeclaration(): Boolean

isJmlDocType

open fun isJmlDocType(): Boolean

isJmlFieldDeclaration

open fun isJmlFieldDeclaration(): Boolean

isJmlMethodDeclaration

open fun isJmlMethodDeclaration(): Boolean

isJmlRepresentsDeclaration

open fun isJmlRepresentsDeclaration(): Boolean

isMethodDeclaration

open fun isMethodDeclaration(): Boolean

isPhantom

open fun isPhantom(): Boolean

isPrivate

open fun isPrivate(): Boolean

isProtected

open fun isProtected(): Boolean

isPublic

open fun isPublic(): Boolean

isRecordDeclaration

open fun isRecordDeclaration(): Boolean

isRegistered

open fun isRegistered(observer: AstObserver): Boolean

Was this observer registered?

isStatic

open fun isStatic(): Boolean

isStrictfp

open fun isStrictfp(): Boolean

isThrown

open fun isThrown(clazz: Class<out Throwable>): Boolean

Check whether this elements throws this exception class.

open fun isThrown(throwableName: String): Boolean

Check whether this elements throws this exception class Note that this is simply a text compare, no actual type resolution takes place.

isTypeDeclaration

open fun isTypeDeclaration(): Boolean

isVariableArityMethod

open fun isVariableArityMethod(): Boolean

modifiers

@NonNull

open fun modifiers(): @NonNull NodeList<Modifier>

name

@NonNull

open fun name(): @NonNull SimpleName

notifyPropertyChange

open fun <P> notifyPropertyChange(property: ObservableProperty, oldValue: P, newValue: P)

parameters

@NonNull

open fun parameters(): @NonNull NodeList<Parameter>

receiverParameter

@Nullable

open fun receiverParameter(): @Nullable ReceiverParameter

open fun register(observer: AstObserver)

open fun register(observer: AstObserver, mode: Node.ObserverRegistrationMode)

registerForSubtree

open fun registerForSubtree(observer: AstObserver)

remove

open fun remove(): Boolean

Try to remove this node from the parent

open fun remove(node: Node): Boolean

removeBody

open fun removeBody(): ConstructorDeclaration

removeComment

open fun removeComment(): Node

removeData

open fun removeData(key: DataKey<out Any>)

Remove data by key.

removeForced

open fun removeForced()

Forcibly removes this node from the AST.

removeJavaDocComment

open fun removeJavaDocComment(): Boolean

removeModifier

open fun removeModifier(modifiersToRemove: Array<Modifier.Keyword>): N

removeOrphanComment

open fun removeOrphanComment(comment: Comment): Boolean

removeReceiverParameter

open fun removeReceiverParameter(): CallableDeclaration

replace

open fun replace(node: Node): Boolean

Try to replace this node in the parent with the supplied node.

open fun replace(node: Node, replacementNode: Node): Boolean

resolve

open fun resolve(): ResolvedConstructorDeclaration

setAbstract

open fun setAbstract(set: Boolean): N

setAnnotation

open fun setAnnotation(i: Int, element: AnnotationExpr): N

setAssociatedSpecificationComments

open fun setAssociatedSpecificationComments(@Nullable associatedSpecificationComments: @Nullable NodeList<Comment>): Node

setBlockComment

fun setBlockComment(comment: String): Node

Use this to store additional information to this node.

setBody

open fun setBody(@Nullable body: @Nullable BlockStmt): ConstructorDeclaration

Sets the body

setData

open fun <M> setData(key: DataKey<M>, object: M)

Sets data for this node using the given key.

setFinal

open fun setFinal(set: Boolean): N

setJavadocComment

open fun setJavadocComment(comment: JavadocComment): N

open fun setJavadocComment(javadoc: Javadoc): N

open fun setJavadocComment(indentation: String, javadoc: Javadoc): N

open fun setJavadocComment(comment: String): N

open fun setJavadocComment(comment: String, isMarkdownComment: Boolean): N

Set a JavadocComment for this node

setLineComment

fun setLineComment(comment: String): Node

Use this to store additional information to this node.

setModifier

open fun setModifier(m: Modifier.Keyword, set: Boolean): N

setModifiers

open fun setModifiers(modifiers: NodeList<Modifier>): ConstructorDeclaration

open fun setModifiers(modifiers: Array<Modifier.Keyword>): N

open fun setModifiers(modifiers: List<Modifier.Keyword>): N

Creates a list of modifier nodes corresponding to the keywords passed, and set it.

setName

open fun setName(name: SimpleName): ConstructorDeclaration

open fun setName(name: String): N

setParameter

open fun setParameter(i: Int, parameter: Parameter): N

setParameters

open fun setParameters(parameters: NodeList<Parameter>): ConstructorDeclaration

setPrivate

open fun setPrivate(set: Boolean): N

setProtected

open fun setProtected(set: Boolean): N

setPublic

open fun setPublic(set: Boolean): N

setReceiverParameter

open fun setReceiverParameter(@Nullable receiverParameter: @Nullable ReceiverParameter): T

setStatic

open fun setStatic(set: Boolean): N

setStrictfp

open fun setStrictfp(set: Boolean): N

setThrownExceptions

open fun setThrownExceptions(thrownExceptions: NodeList<ReferenceType>): ConstructorDeclaration

setTypeParameter

open fun setTypeParameter(i: Int, typeParameter: TypeParameter): N

setTypeParameters

open fun setTypeParameters(typeParameters: NodeList<TypeParameter>): ConstructorDeclaration

stream

open fun stream(): Stream<Node>

Make a stream of nodes using pre-order traversal.

open fun stream(traversal: Node.TreeTraversal): Stream<Node>

Make a stream of nodes using traversal algorithm "traversal".

thrownExceptions

@NonNull

open fun thrownExceptions(): @NonNull NodeList<ReferenceType>

toAnnotationDeclaration

open fun toAnnotationDeclaration(): Optional<AnnotationDeclaration>

toAnnotationMemberDeclaration

open fun toAnnotationMemberDeclaration(): Optional<AnnotationMemberDeclaration>

toCallableDeclaration

open fun toCallableDeclaration(): Optional<CallableDeclaration>

toClassOrInterfaceDeclaration

open fun toClassOrInterfaceDeclaration(): Optional<ClassOrInterfaceDeclaration>

toCompactConstructorDeclaration

open fun toCompactConstructorDeclaration(): Optional<CompactConstructorDeclaration>

toConstructorDeclaration

open fun toConstructorDeclaration(): Optional<ConstructorDeclaration>

toDescriptor

open fun toDescriptor(): String

toEnumConstantDeclaration

open fun toEnumConstantDeclaration(): Optional<EnumConstantDeclaration>

toEnumDeclaration

open fun toEnumDeclaration(): Optional<EnumDeclaration>

toFieldDeclaration

open fun toFieldDeclaration(): Optional<FieldDeclaration>

toInitializerDeclaration

open fun toInitializerDeclaration(): Optional<InitializerDeclaration>

toJmlClassAccessibleDeclaration

open fun toJmlClassAccessibleDeclaration(): Optional<JmlClassAccessibleDeclaration>

toJmlClassExprDeclaration

open fun toJmlClassExprDeclaration(): Optional<JmlClassExprDeclaration>

toJmlClassLevelDeclaration

open fun toJmlClassLevelDeclaration(): Optional<JmlClassLevelDeclaration>

toJmlDocDeclaration

open fun toJmlDocDeclaration(): Optional<JmlDocDeclaration>

toJmlDocType

open fun toJmlDocType(): Optional<JmlDocType>

toJmlFieldDeclaration

open fun toJmlFieldDeclaration(): Optional<JmlFieldDeclaration>

toJmlMethodDeclaration

open fun toJmlMethodDeclaration(): Optional<JmlMethodDeclaration>

toJmlRepresentsDeclaration

open fun toJmlRepresentsDeclaration(): Optional<JmlRepresentsDeclaration>

toMethodDeclaration

open fun toMethodDeclaration(): Optional<MethodDeclaration>

toRecordDeclaration

open fun toRecordDeclaration(): Optional<RecordDeclaration>

toString

fun toString(): String

fun toString(configuration: PrinterConfiguration): String

toTypeDeclaration

open fun toTypeDeclaration(): Optional<TypeDeclaration>

tryAddImportToParentCompilationUnit

abstract fun tryAddImportToParentCompilationUnit(clazz: Class<out Any>)

typeParameters

@NonNull

open fun typeParameters(): @NonNull NodeList<TypeParameter>

unregister

open fun unregister(observer: AstObserver)

Unregister an observer.

walk

open fun walk(consumer: Consumer<Node>)

Walks the AST, calling the consumer for every node with pre-order traversal.

open fun walk(traversal: Node.TreeTraversal, consumer: Consumer<Node>)

Walks the AST, calling the consumer for every node, with traversal algorithm "traversal".

open fun <T : Node?> walk(nodeType: Class<T>, consumer: Consumer<T>)

Walks the AST with pre-order traversal, calling the consumer for every node of type "nodeType".