All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
| Class |
Description |
| AccessSpecifier |
Access specifier.
|
| Added |
|
| AllFieldsConstructor |
Tells tools that this is the constructor which directly initializes all fields (except "range" and "comment")
|
| AnnotationDeclaration |
An annotation type declaration.
@interface X { ...
|
| AnnotationDeclarationMetaModel |
|
| AnnotationExpr |
A base class for the different types of annotations.
|
| AnnotationExprMetaModel |
|
| AnnotationMemberDeclaration |
The "int id();" in @interface X { int id(); }
|
| AnnotationMemberDeclarationMetaModel |
|
| ArrayAccessExpr |
Array brackets [] being used to get a value from an array.
|
| ArrayAccessExprMetaModel |
|
| ArrayCreationExpr |
new int[5][4][][] or new int[][]{{1},{2,3}}.
|
| ArrayCreationExprMetaModel |
|
| ArrayCreationLevel |
In new int[1][2]; there are two ArrayCreationLevel objects,
the first one contains the expression "1",
the second the expression "2".
|
| ArrayCreationLevelMetaModel |
|
| ArrayInitializerExpr |
The initialization of an array.
|
| ArrayInitializerExprMetaModel |
|
| ArrayType |
To indicate that a type is an array, it gets wrapped in an ArrayType for every array level it has.
|
| ArrayType.ArrayBracketPair |
Helper class that stores information about a pair of brackets in a non-recursive way
(unlike ArrayType.)
|
| ArrayType.Origin |
The origin of a pair of array brackets [].
|
| ArrayTypeMetaModel |
|
| AssertStmt |
A usage of the keyword "assert"
In assert dead : "Wasn't expecting to be dead here"; the check is "dead" and the message is the string.
|
| AssertStmtMetaModel |
|
| AssignExpr |
An assignment expression.
|
| AssignExpr.Operator |
|
| AssignExprMetaModel |
|
| AssociableToAST<N extends Node> |
A declaration that can be potentially associated with an AST node.
|
| AstObserver |
An Observer for an AST element (either a Node or a NodeList).
|
| AstObserver.ListChangeType |
Type of change occurring on a List
|
| AstObserverAdapter |
|
| BaseNodeMetaModel |
Meta-data about all classes in the AST.
|
| BinaryExpr |
An expression with an expression on the left, an expression on the right, and an operator in the middle.
|
| BinaryExpr.Operator |
|
| BinaryExprMetaModel |
|
| BlockComment |
AST node that represent block comments.
|
| BlockCommentMetaModel |
|
| BlockStmt |
Statements in between { and }.
|
| BlockStmtMetaModel |
|
| BodyDeclaration<T extends BodyDeclaration<?>> |
Any declaration that can appear between the { and } of a class, interface, or enum.
|
| BodyDeclarationMetaModel |
|
| BooleanLiteralExpr |
The boolean literals.
|
| BooleanLiteralExprMetaModel |
|
| BreakStmt |
The break statement
|
| BreakStmtMetaModel |
|
| CallableDeclaration<T extends CallableDeclaration<?>> |
Represents a declaration which is callable eg.
|
| CallableDeclaration.Signature |
A method or constructor signature.
|
| CallableDeclarationMetaModel |
|
| CastExpr |
A typecast.
|
| CastExprMetaModel |
|
| CatchClause |
The catch part of a try-catch-finally.
|
| CatchClauseMetaModel |
|
| Change |
This represent a change happened to a specific Node.
|
| CharLiteralExpr |
A literal character.
|
| CharLiteralExprMetaModel |
|
| ClassExpr |
Defines an expression that accesses the class of a type.
|
| ClassExprMetaModel |
|
| ClassOrInterfaceDeclaration |
A definition of a class or interface.
class X { ...
|
| ClassOrInterfaceDeclarationMetaModel |
|
| ClassOrInterfaceType |
A class or an interface type.
|
| ClassOrInterfaceTypeMetaModel |
|
| ClassUtils |
|
| CloneVisitor |
A visitor that clones (copies) a node and all its children.
|
| CodeGenerationUtils |
Utilities that can be useful when generating code.
|
| CollectionStrategy |
A strategy for discovering the structure of a project.
|
| Comment |
Abstract class for all AST nodes that represent comments.
|
| CommentMetaModel |
|
| CommentsCollection |
The comments contained in a certain parsed piece of source code.
|
| CommonValidators |
Contains validations that are valid for every Java version.
|
| CompilationUnit |
This class represents the entire compilation unit.
|
| CompilationUnit.Storage |
Information about where this compilation unit was loaded from.
|
| CompilationUnitMetaModel |
|
| ConcreteSyntaxModel |
The Concrete Syntax Model for a single node type.
|
| ConditionalExpr |
The ternary conditional expression.
|
| ConditionalExprMetaModel |
|
| ConstructorDeclaration |
A constructor declaration: class X { X() { } } where X(){} is the constructor declaration.
|
| ConstructorDeclarationMetaModel |
|
| ContinueStmt |
A continue statement with an optional label;
continue brains;
continue;
|
| ContinueStmtMetaModel |
|
| CsmAttribute |
|
| CsmChar |
|
| CsmComment |
|
| CsmConditional |
|
| CsmConditional.Condition |
|
| CsmElement |
|
| CsmIndent |
|
| CsmList |
|
| CsmMix |
A group of elements that could be in any order.
|
| CsmNone |
|
| CsmOrphanCommentsEnding |
|
| CsmSequence |
|
| CsmSingleReference |
|
| CsmString |
|
| CsmTextBlock |
|
| CsmToken |
|
| CsmToken.TokenContentCalculator |
|
| CsmUnindent |
|
| DataKey<T> |
A key to a piece of data associated with a Node at runtime. |
| DerivedProperty |
Indicate a derived property of a Node,
meaning it does supply useful information,
but it does so by taking information from other properties.
|
| Difference |
A Difference should give me a sequence of elements I should find (to indicate the context) followed by a list of elements
to remove or to add and follow by another sequence of elements.
|
| DifferenceElement |
|
| DoStmt |
A do-while.
|
| DoStmtMetaModel |
|
| DotPrinter |
Outputs a Graphviz diagram of the AST.
|
| DoubleLiteralExpr |
A float or a double constant.
|
| DoubleLiteralExprMetaModel |
|
| EmptyStmt |
An empty statement is a ";" where a statement is expected.
|
| EmptyStmtMetaModel |
|
| EnclosedExpr |
An expression between ( ).
|
| EnclosedExprMetaModel |
|
| EnumConstantDeclaration |
One of the values an enum can take.
|
| EnumConstantDeclarationMetaModel |
|
| EnumDeclaration |
The declaration of an enum.
enum X { ...
|
| EnumDeclarationMetaModel |
|
| EqualsVisitor |
A visitor that calculates deep node equality by comparing all properties and child nodes of the node.
|
| ExplicitConstructorInvocationStmt |
A call to super or this in a constructor or initializer.
|
| ExplicitConstructorInvocationStmtMetaModel |
|
| Expression |
A base class for all expressions.
|
| ExpressionMetaModel |
|
| ExpressionStmt |
Used to wrap an expression so that it can take the place of a statement.
|
| ExpressionStmtMetaModel |
|
| FieldAccessExpr |
Access of a field of an object or a class.
|
| FieldAccessExprMetaModel |
|
| FieldDeclaration |
The declaration of a field in a class.
|
| FieldDeclarationMetaModel |
|
| ForEachStmt |
A for-each statement.
|
| ForEachStmtMetaModel |
|
| ForStmt |
The classic for statement
|
| ForStmtMetaModel |
|
| Generated |
Copied from javax.annotation.Generated and reduced a bit.
|
| GeneratedJavaParserConstants |
Token literal values and constants.
|
| GeneratedJavaParserTokenManager |
Token Manager.
|
| GenericListVisitorAdapter<R,A> |
A visitor that has a return value of ( List), and has a default implementation for all its visit
methods that visits their children in an unspecified order, and all visit methods
that returns a value be added to a flattened List. |
| GenericVisitor<R,A> |
A visitor that has a return value.
|
| GenericVisitorAdapter<R,A> |
A visitor that has a return value (R), and has a default implementation for all its visit
methods that visits their children in an unspecified order, and the first visit method
that returns a value will stop the visitation and be the end result.
|
| GenericVisitorWithDefaults<R,A> |
A visitor that has a return value (R), and has default methods that are used when a specific visit method is not
overridden.
|
| HasAccessSpecifier |
Anything which can have an AccessSpecifier.
|
| HashCodeVisitor |
A visitor that calculates a deep hash code for a node by using the hash codes of all its properties,
and the hash codes of all its child nodes (by visiting those too.)
|
| HasParentNode<T> |
An object that can have a parent node.
|
| IfStmt |
An if-then-else statement.
|
| IfStmtMetaModel |
|
| ImportDeclaration |
An import declaration.
|
| ImportDeclarationMetaModel |
|
| InitializerDeclaration |
A (possibly static) initializer body.
|
| InitializerDeclarationMetaModel |
|
| InstanceOfExpr |
Usage of the instanceof operator.
|
| InstanceOfExprMetaModel |
|
| IntegerLiteralExpr |
All ways to specify an int literal.
|
| IntegerLiteralExprMetaModel |
|
| InternalProperty |
Indicate an internal property of a Node,
meaning it is not part of the meta model.
|
| IntersectionType |
Represents a set of types.
|
| IntersectionTypeMetaModel |
|
| Java1_0Validator |
This validator validates according to Java 1.0 syntax rules.
|
| Java1_1Validator |
This validator validates according to Java 1.1 syntax rules.
|
| Java1_2Validator |
This validator validates according to Java 1.2 syntax rules.
|
| Java1_3Validator |
This validator validates according to Java 1.3 syntax rules.
|
| Java1_4Validator |
This validator validates according to Java 1.4 syntax rules.
|
| Java10PostProcessor |
Processes the generic AST into a Java 10 AST and validates it.
|
| Java10Validator |
This validator validates according to Java 10 syntax rules.
|
| Java11PostProcessor |
Processes the generic AST into a Java 11 AST and validates it.
|
| Java11Validator |
This validator validates according to Java 11 syntax rules.
|
| Java12PostProcessor |
Processes the generic AST into a Java 12 AST and validates it.
|
| Java12Validator |
This validator validates according to Java 12 syntax rules.
|
| Java13PostProcessor |
Processes the generic AST into a Java 13 AST and validates it.
|
| Java13Validator |
This validator validates according to Java 13 syntax rules.
|
| Java14PostProcessor |
Processes the generic AST into a Java 14 AST and validates it.
|
| Java14Validator |
This validator validates according to Java 14 syntax rules.
|
| Java5Validator |
This validator validates according to Java 5 syntax rules.
|
| Java6Validator |
This validator validates according to Java 6 syntax rules.
|
| Java7Validator |
This validator validates according to Java 7 syntax rules.
|
| Java8Validator |
This validator validates according to Java 7 syntax rules.
|
| Java9Validator |
This validator validates according to Java 9 syntax rules.
|
| Javadoc |
The structured content of a single Javadoc comment.
|
| JavadocBlockTag |
A block tag.
|
| JavadocBlockTag.Type |
The type of tag: it could either correspond to a known tag (param, return, etc.) or represent
an unknown tag.
|
| JavadocComment |
A Javadoc comment.
|
| JavadocCommentMetaModel |
|
| JavadocDescription |
A javadoc text, potentially containing inline tags.
|
| JavadocDescriptionElement |
An element of a description: either an inline tag or a piece of text.
|
| JavadocInlineTag |
An inline tag contained in a Javadoc description.
|
| JavadocInlineTag.Type |
The type of tag: it could either correspond to a known tag (code, docRoot, etc.) or represent
an unknown tag.
|
| JavadocSnippet |
A piece of text inside a Javadoc description.
|
| JavaParser |
Parse Java source code and creates Abstract Syntax Trees.
|
| JavaParserBuild |
Some information that was available when this library was built by Maven.
|
| JavaParserMetaModel |
|
| JavaToken |
A token from a parsed source file.
|
| JavaToken.Category |
|
| JavaToken.Kind |
|
| Kept |
|
| LabeledStmt |
A statement that is labeled, like label123: println("continuing");
|
| LabeledStmtMetaModel |
|
| LambdaExpr |
A lambda expression
|
| LambdaExprMetaModel |
|
| LexicalPreservingPrinter |
A Lexical Preserving Printer is used to capture all the lexical information while parsing, update them when
operating on the AST and then used them to reproduce the source code
in its original formatting including the AST changes.
|
| LineComment |
AST node that represent line comments.
|
| LineCommentMetaModel |
|
| ListAdditionChange |
The Addition of an element to a list.
|
| ListRemovalChange |
The removal of an element in a list.
|
| ListReplacementChange |
The replacement of an element in a list.
|
| LiteralExpr |
A base class for all literal expressions.
|
| LiteralExprMetaModel |
|
| LiteralStringValueExpr |
Any literal value that is stored internally as a String.
|
| LiteralStringValueExprMetaModel |
|
| LocalClassDeclarationStmt |
A class declaration inside a method.
|
| LocalClassDeclarationStmtMetaModel |
|
| Log |
To avoid dependencies on logging frameworks, we have invented yet another logging framework :-)
|
| Log.Adapter |
|
| Log.SilentAdapter |
This adapter logs nothing.
|
| Log.StandardOutStandardErrorAdapter |
This adapter logs to standard out and standard error.
|
| LongLiteralExpr |
All ways to specify a long literal.
|
| LongLiteralExprMetaModel |
|
| MarkerAnnotationExpr |
An annotation that uses only the annotation type name.
|
| MarkerAnnotationExprMetaModel |
|
| MemberValuePair |
A value for a member of an annotation.
|
| MemberValuePairMetaModel |
|
| MethodAmbiguityException |
It is not possible to decide how to resolve a method invocation.
|
| MethodCallExpr |
A method call on an object or a class.
|
| MethodCallExprMetaModel |
|
| MethodDeclaration |
A method declaration.
|
| MethodDeclarationMetaModel |
|
| MethodReferenceExpr |
Method reference expressions introduced in Java 8 specifically designed to simplify lambda Expressions.
|
| MethodReferenceExprMetaModel |
|
| MethodUsage |
This is basically a MethodDeclaration with some TypeParameters defined.
|
| Modifier |
A modifier, like private, public, or volatile.
|
| Modifier.Keyword |
The Java modifier keywords.
|
| ModifierMetaModel |
|
| ModifierValidator |
Verifies that only allowed modifiers are used where modifiers are expected.
|
| ModifierVisitor<A> |
This visitor can be used to save time when some specific nodes needs
to be changed.
|
| ModuleDeclaration |
A Java 9 Jigsaw module declaration.
|
| ModuleDeclarationMetaModel |
|
| ModuleDirective |
A module directive.
|
| ModuleDirectiveMetaModel |
|
| ModuleExportsDirective |
An exports directive in module-info.java.
|
| ModuleExportsDirectiveMetaModel |
|
| ModuleOpensDirective |
An opens directive in module-info.java.
|
| ModuleOpensDirectiveMetaModel |
|
| ModuleProvidesDirective |
A provides directive in module-info.java.
|
| ModuleProvidesDirectiveMetaModel |
|
| ModuleRequiresDirective |
A require directive in module-info.java.
|
| ModuleRequiresDirectiveMetaModel |
|
| ModuleUsesDirective |
A uses directive in module-info.java.
|
| ModuleUsesDirectiveMetaModel |
|
| Name |
A name that may consist of multiple identifiers.
|
| NameExpr |
Whenever a SimpleName is used in an expression, it is wrapped in NameExpr.
|
| NameExprMetaModel |
|
| NameMetaModel |
|
| NoBinaryIntegerLiteralsValidator |
|
| NoChange |
No change.
|
| NoCommentEqualsVisitor |
|
| NoCommentHashCodeVisitor |
|
| Node |
Base class for all nodes of the abstract syntax tree.
|
| Node.BreadthFirstIterator |
Performs a breadth-first node traversal starting with a given node.
|
| Node.DirectChildrenIterator |
Performs a simple traversal over all nodes that have the passed node as their parent.
|
| Node.ObserverRegistrationMode |
Different registration mode for observers on nodes.
|
| Node.ParentsVisitor |
Iterates over the parent of the node, then the parent's parent, then the parent's parent's parent, until running
out of parents.
|
| Node.Parsedness |
|
| Node.PostOrderIterator |
Performs a post-order (or leaves-first) node traversal starting with a given node.
|
| Node.PreOrderIterator |
Performs a pre-order (or depth-first) node traversal starting with a given node.
|
| Node.TreeTraversal |
|
| NodeList<N extends Node> |
A list of nodes.
|
| NodeMetaModel |
|
| NodeWithAbstractModifier<N extends Node> |
A node that can be abstract.
|
| NodeWithAccessModifiers<N extends Node> |
A node that can be public, protected, and/or private.
|
| NodeWithAnnotations<N extends Node> |
A node that can be annotated.
|
| NodeWithArguments<N extends Node> |
A node with arguments.
|
| NodeWithBlockStmt<N extends Node> |
A node with a body that is a BlockStmt.
|
| NodeWithBody<N extends Node> |
|
| NodeWithCondition<N extends Node> |
|
| NodeWithDeclaration |
Node with a declaration representable as a String.
|
| NodeWithExpression<N extends Node> |
A node that has an expression in it.
|
| NodeWithExtends<N extends Node> |
A node that extends other types.
|
| NodeWithFinalModifier<N extends Node> |
A node that can be final.
|
| NodeWithIdentifier<N extends Node> |
|
| NodeWithImplements<N extends Node> |
A node that implements other types.
|
| NodeWithJavadoc<N extends Node> |
A node that can be documented with a Javadoc comment.
|
| NodeWithMembers<N extends Node> |
A node having members.
|
| NodeWithModifiers<N extends Node> |
A Node with Modifiers.
|
| NodeWithName<N extends Node> |
A node with a (qualified) name.
|
| NodeWithOptionalBlockStmt<N extends Node> |
A node with a body that is a BlockStmt, which is optional.
|
| NodeWithOptionalLabel<T extends Node> |
A node that has an optional label.
|
| NodeWithOptionalScope<N extends Node> |
Represents a node which has an optional scope expression eg.
|
| NodeWithParameters<N extends Node> |
|
| NodeWithPrivateModifier<N extends Node> |
A node that can be private.
|
| NodeWithProtectedModifier<N extends Node> |
A node that can be protected.
|
| NodeWithPublicModifier<N extends Node> |
A node that can be public.
|
| NodeWithRange<N> |
A node that has a Range, which is every Node.
|
| NodeWithScope<N extends Node> |
Represents a node which has a required scope expression eg.
|
| NodeWithSimpleName<N extends Node> |
A node with a name.
|
| NodeWithStatements<N extends Node> |
A node that contains a list of statements.
|
| NodeWithStaticModifier<N extends Node> |
A node that can be static.
|
| NodeWithStrictfpModifier<N extends Node> |
A node that can be strictfp.
|
| NodeWithThrownExceptions<N extends Node> |
A node that declares the types of exception it throws.
|
| NodeWithTokenRange<N> |
A node that has a Range, which is every Node.
|
| NodeWithTraversableScope |
Represents a node which has a scope expression that can be traversed/walked.
|
| NodeWithType<N extends Node,T extends Type> |
A node with a type.
|
| NodeWithTypeArguments<N extends Node> |
A node that can have type arguments.
|
| NodeWithTypeParameters<N extends Node> |
A node that can have type parameters.
|
| NodeWithVariables<N extends Node> |
A node which has a list of variables.
|
| NonEmptyProperty |
Indicate that leaving this property empty does not lead to a correct AST.
|
| NormalAnnotationExpr |
An annotation that has zero or more key-value pairs.
@Mapping(a=5, d=10)
|
| NormalAnnotationExprMetaModel |
|
| NoUnderscoresInIntegerLiteralsValidator |
|
| NullLiteralExpr |
A literal "null".
|
| NullLiteralExprMetaModel |
|
| ObjectCreationExpr |
A constructor call.
|
| ObjectCreationExprMetaModel |
|
| ObjectIdentityEqualsVisitor |
A visitor that calculates deep node equality by comparing all properties and child nodes of the node.
|
| ObjectIdentityHashCodeVisitor |
A visitor that calculates a deep hash code for a node by using the hash codes of all its properties,
and the hash codes of all its child nodes (by visiting those too.)
|
| Observable |
Observable element.
|
| ObservableProperty |
Properties considered by the AstObserver
|
| OptionalProperty |
Indicate an optional property of a Node.
|
| PackageDeclaration |
A package declaration.
|
| PackageDeclarationMetaModel |
|
| Pair<A,B> |
Simply a pair of objects.
|
| Parameter |
The parameters to a method or lambda.
|
| ParameterMetaModel |
|
| ParseException |
This exception is thrown when parse errors are encountered.
|
| ParseProblemException |
Thrown when parsing problems occur during parsing with the static methods on JavaParser.
|
| ParserCollectionStrategy |
|
| ParserConfiguration |
The configuration that is used by the parser.
|
| ParserConfiguration.LanguageLevel |
|
| ParseResult<T> |
The results given when parsing with an instance of JavaParser.
|
| ParseResult.PostProcessor |
A post processor that can be added to ParserConfiguration to add some processing right after parsing.
|
| ParseStart<R> |
The start production for JavaParser.
|
| Position |
A position in a source file.
|
| PositionUtils |
|
| PostProcessors |
A post processor that will call a collection of post processors.
|
| PrettyPrinter |
Pretty printer for AST nodes.
|
| PrettyPrinterConfiguration |
|
| PrettyPrinterConfiguration.IndentType |
|
| PrettyPrintVisitor |
Outputs the AST as formatted Java source code.
|
| PrimitiveType |
A primitive type.
|
| PrimitiveType.Primitive |
|
| PrimitiveTypeMetaModel |
|
| Printable |
Something that has a printable form.
|
| Problem |
A problem that was encountered during parsing.
|
| ProblemReporter |
A simple interface where validators can report found problems.
|
| ProjectRoot |
The structure of a Java project directory.
|
| PropagatingAstObserver |
This AstObserver attach itself to all new nodes added to the nodes already observed.
|
| PropertyChange |
The change in value of a property.
|
| PropertyMetaModel |
Meta-data about a property of a node in the AST.
|
| Provider |
|
| Providers |
Factory for providers of source code for JavaParser.
|
| Providers.PreProcessor |
|
| Range |
A range of characters in a source file, from "begin" to "end", including the characters at "begin" and "end".
|
| ReceiverParameter |
|
| ReceiverParameterMetaModel |
|
| ReferenceType |
Base class for reference types.
|
| ReferenceTypeMetaModel |
|
| Removed |
|
| ReservedKeywordValidator |
Validates that identifiers are not keywords - this for the few keywords that the parser
accepts because they were added after Java 1.0.
|
| Reshuffled |
Elements in a CsmMix have been reshuffled.
|
| Resolvable<T> |
|
| ResolvedAnnotationDeclaration |
|
| ResolvedAnnotationMemberDeclaration |
|
| ResolvedArrayType |
Array Type.
|
| ResolvedClassDeclaration |
Declaration of a Class (not an interface or an enum).
|
| ResolvedConstructorDeclaration |
A declaration of a constructor.
|
| ResolvedDeclaration |
A generic declaration.
|
| ResolvedEnumConstantDeclaration |
|
| ResolvedEnumDeclaration |
Declaration of an Enum.
|
| ResolvedFieldDeclaration |
Declaration of a field.
|
| ResolvedInterfaceDeclaration |
An interface declaration.
|
| ResolvedIntersectionType |
An intersection type is defined in java as list of types separates by ampersands.
|
| ResolvedLambdaConstraintType |
|
| ResolvedMethodDeclaration |
A declaration of a method (either in an interface, a class, an enum or an annotation).
|
| ResolvedMethodLikeDeclaration |
This is a common interface for MethodDeclaration and ConstructorDeclaration.
|
| ResolvedParameterDeclaration |
Declaration of a parameter.
|
| ResolvedPrimitiveType |
|
| ResolvedReferenceType |
A ReferenceType like a class, an interface or an enum.
|
| ResolvedReferenceTypeDeclaration |
|
| ResolvedType |
A resolved type.
|
| ResolvedTypeDeclaration |
A declaration of a type.
|
| ResolvedTypeParameterDeclaration |
Declaration of a type parameter.
|
| ResolvedTypeParameterDeclaration.Bound |
A Bound on a Type Parameter.
|
| ResolvedTypeParametersMap |
A map of values associated to TypeParameters.
|
| ResolvedTypeParametersMap.Builder |
|
| ResolvedTypeParameterValueProvider |
|
| ResolvedTypeParametrizable |
An entity which has type parameter.
|
| ResolvedTypeParametrized |
Something which can have values for TypeParameters.
|
| ResolvedTypeTransformer |
|
| ResolvedTypeVariable |
From JLS 4.4: A type variable is introduced by the declaration of a type parameter of a generic class,
interface, method, or constructor (§8.1.2, §9.1.2, §8.4.4, §8.8.4).
|
| ResolvedUnionType |
A union type is defined in java as list of types separates by pipes.
|
| ResolvedValueDeclaration |
Declaration of a value.
|
| ResolvedVoidType |
The special type void.
|
| ResolvedWildcard |
A wildcard can be:
- unbounded (?)
- have a lower bound (? super Number)
- have an upper bound (? extends Number)
It is not possible to have both a lower and an upper bound at the same time.
|
| ResolvedWildcard.BoundType |
|
| ReturnStmt |
The return statement, with an optional expression to return.
|
| ReturnStmtMetaModel |
|
| SeparatedItemStringBuilder |
Builds a string containing a list of items with a prefix, a postfix, and a separator.
|
| SimpleCharStream |
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (without unicode processing).
|
| SimpleName |
A name that consists of a single identifier.
|
| SimpleNameMetaModel |
|
| SimpleValidator<N extends Node> |
Runs a validator on all nodes of a certain type,
and adds a problem for all nodes that pass a condition.
|
| SingleMemberAnnotationExpr |
An annotation that has a single value.
|
| SingleMemberAnnotationExprMetaModel |
|
| SingleNodeTypeValidator<N extends Node> |
Runs a validator on all nodes of a certain type.
|
| SourcePrinter |
A support class for code that outputs formatted source code.
|
| SourceRoot |
A collection of Java source files located in one directory and its subdirectories on the file system.
|
| SourceRoot.Callback |
|
| SourceRoot.Callback.Result |
|
| SourceZip |
A collection of Java source files and its sub-directories located in a ZIP or JAR file on the file system.
|
| SourceZip.Callback |
An interface to define a callback for each file that's parsed.
|
| Statement |
A base class for all statements.
|
| StatementMetaModel |
|
| StaticJavaParser |
|
| StreamProvider |
NOTE : This generated class can be safely deleted if installing in a GWT installation (use StringProvider instead)
|
| StringEscapeUtils |
Adapted from apache commons-lang3 project.
|
| StringLiteralExpr |
A literal string.
|
| StringLiteralExprMetaModel |
|
| StringProvider |
|
| SuperExpr |
An occurrence of the "super" keyword.
|
| SuperExprMetaModel |
|
| SwitchEntry |
One case in a switch statement
|
| SwitchEntry.Type |
|
| SwitchEntryMetaModel |
|
| SwitchExpr |
The switch expression
|
| SwitchExprMetaModel |
|
| SwitchNode |
|
| SwitchStmt |
The switch statement
|
| SwitchStmtMetaModel |
|
| SymbolResolver |
|
| SynchronizedStmt |
Usage of the synchronized keyword.
|
| SynchronizedStmtMetaModel |
|
| TextBlockLiteralExpr |
A text block
|
| TextBlockLiteralExprMetaModel |
|
| TextElement |
|
| TextElementMatcher |
|
| ThisExpr |
An occurrence of the "this" keyword.
|
| ThisExprMetaModel |
|
| ThrowStmt |
Usage of the throw statement.
|
| ThrowStmtMetaModel |
|
| Token |
Describes the input token stream.
|
| TokenMgrException |
Token Manager Error.
|
| TokenRange |
The range of tokens covered by this node.
|
| TokenTypes |
Complements GeneratedJavaParserConstants
|
| TreeVisitor |
Iterate over all the nodes in (a part of) the AST.
|
| TreeVisitorValidator |
A validator that walks the whole tree, visiting every node.
|
| TryStmt |
The try statement
|
| TryStmtMetaModel |
|
| Type |
Base class for types.
|
| TypeDeclaration<T extends TypeDeclaration<?>> |
A base class for all types of type declarations.
|
| TypeDeclarationMetaModel |
|
| TypedValidator<N extends Node> |
A validator that validates a known node type.
|
| TypeExpr |
This class is just instantiated as scopes for MethodReferenceExpr nodes to encapsulate Types.
|
| TypeExprMetaModel |
|
| TypeMetaModel |
|
| TypeParameter |
A type parameter.
|
| TypeParameterMetaModel |
|
| UnaryExpr |
An expression where an operator is applied to a single expression.
|
| UnaryExpr.Operator |
|
| UnaryExprMetaModel |
|
| UnderscoreKeywordValidator |
|
| UnicodeEscapeProcessingProvider |
Provider un-escaping unicode escape sequences in the input sequence. |
| UnicodeEscapeProcessingProvider.LineCounter |
Processor keeping track of the current line and column in a stream of
incoming characters.
|
| UnicodeEscapeProcessingProvider.PositionMapping |
An algorithm mapping Position form two corresponding files. |
| UnicodeEscapeProcessingProvider.PositionMapping.PositionUpdate |
Algorithm updating a Position from one file to a
Position in a corresponding file. |
| UnionType |
The union type
|
| UnionTypeMetaModel |
|
| UnknownType |
An unknown parameter type object.
|
| UnknownTypeMetaModel |
|
| UnparsableStmt |
A statement that had parse errors.
|
| UnparsableStmtMetaModel |
|
| UnsolvedSymbolException |
This exception is thrown when a symbol cannot be resolved.
|
| Utils |
Any kind of utility.
|
| Validator |
A validator that can be run on a node to check for semantic errors.
|
| Validators |
A validator that will call a collection of validators.
|
| VariableDeclarationExpr |
A declaration of variables.
|
| VariableDeclarationExprMetaModel |
|
| VariableDeclarator |
The declaration of a variable.
In int x = 14, y = 3; "int x = 14" and "int y = 3" are
VariableDeclarators.
|
| VariableDeclaratorMetaModel |
|
| VarType |
A type called "var" waiting for Java to infer it.
|
| VarTypeMetaModel |
|
| VarValidator |
|
| Visitable |
|
| VisitorList<N extends Node> |
A list that overrides the equals and hashcode calculation of the added nodes
by using another equals and hashcode visitor for those methods.
|
| VisitorMap<N extends Node,V> |
A map that overrides the equals and hashcode calculation of the added nodes
by using another equals and hashcode visitor for those methods.
|
| VisitorSet<N extends Node> |
A set that overrides the equals and hashcode calculation of the added nodes
by using another equals and hashcode visitor for those methods.
|
| VisitorValidator |
A validator that uses a visitor for validation.
|
| VoidType |
|
| VoidTypeMetaModel |
|
| VoidVisitor<A> |
A visitor that does not return anything.
|
| VoidVisitorAdapter<A> |
A visitor that returns nothing, and has a default implementation for all its visit
methods that simply visit their children in an unspecified order.
|
| VoidVisitorWithDefaults<A> |
A visitor that returns nothing, and has default methods that are used when a specific visit method is not
overridden.
|
| WhileStmt |
A while statement.
|
| WhileStmtMetaModel |
|
| WildcardType |
A wildcard type argument.
|
| WildcardTypeMetaModel |
|
| WrappingRangeIterator |
|
| XmlPrinter |
Outputs an XML file containing the AST meant for inspecting it.
|
| YamlPrinter |
Outputs a YAML file containing the AST meant for inspecting it.
|
| YieldStmt |
The yield statement
|
| YieldStmtMetaModel |
|