All Classes and Interfaces

Class	Description
AliasedRelation	An aliased relation.
AltRule	Represents a rule with a bunch of alternatives.
Annotation	Represents the use of an annotation.
Annotation.Element
AnnotationDef	Represents an annotation definition.
ArrayInitializer	Represents array initializer used in variable definition.
ArraySubscriptExpression	Represents an "array[i]" expression.
ArrayTypeLiteral	Represents an array type literal.
AssertStatement	Represents an "assert" statement.
BestParser<T>
BetweenExpression	Expression like "expr between a and b".
Binary<T>	Deprecated. Use BinaryOperator instead.
BinaryExpression	Represents binary expression such as "a + b".
BinaryExpression	An expression of binary operator.
BinaryRelationalExpression	An expression like "expr in (select ...)".
BlockStatement	Represents a block.
BooleanLiteral	"true" or "false".
BreakStatement	Represents "break" statement.
Calculator	The main calculator parser.
CastExpression	A cast expression.
CharLiteral	Represents a character literal.
CharPredicate	Evaluates a char to a boolean.
CharPredicates	Provides common CharPredicate implementations.
Checks	Common facilities to check precondition, postcondition and invariants.
ClassDef	Represents a class definition;
ClassInitializerDef	Represents a static initializer or an instance initializer.
ClassLiteral	Represents "Foo.class".
ConditionalExpression	Represents "?:" expression.
ConstructorDef	Represents a constructor definition.
ConstructorReference
ContinueStatement	Represents "continue" statement.
CrossJoinRelation	Models cross join.
DecimalPointNumberLiteral	Represents a decimal point number.
Declaration	Represents interface, class, enum or annotation.
DeclarationParser	Parses class, interface, enum, annotation declarations.
DefBody	Represents the body of interface, class, or annotation.
DelimitedParser<T>	Parses a list of pattern started with a delimiter, separated and optionally ended by the delimiter.
DoubleExpression
DoWhileStatement	Represents the "do ...
EmptyListParser<T>	A parser that always returns an empty mutable list.
EmptyParseError	Empty implementation of ParseErrorDetails for subclasses to override.
EnumDef	Represents an enum definition.
EnumDef.Value	Represents an enum value.
ErrorReporter	Reports parser errors in human-readable format.
Expression	Represents any expression.
Expression	Any expression
Expression
ExpressionListStatement	Represents the comma delimited expression list used in the initializer of a "for" loop.
ExpressionParser	Parses java expression.
ExpressionParser	Parser for expressions.
ExpressionStatement	Represents a method call statement.
FieldDef	Represents a field definition.
ForeachStatement	Represents the enhanced for loop statement.
ForStatement	Represents the traditional for loop.
FullCaseExpression	The "case when cond1 then val1 when cond2 then val2 else def end" expression.
FullExpression
FunctionExpression	A function call.
GroupBy	"group by" clause.
IdentExpression
Identifier	Represents a simple name as expression.
IfStatement	Represents an "if" statement.
Import	Represents an import statement.
Indentation	Processes indentation based lexical structure according to the Off-side rule.
Indentation.Punctuation
InstanceOfExpression	Represents "expr instanceof type".
IntegerLiteral	Represents any integral number literal.
IntegerLiteral.Radix
InterfaceDef	Represents an interface definition.
InternalFunctors	Functors used only internally by this package.
IntList	A simple, efficient and dynamic int list.
IntOrder	Maps two integers to a boolean value.
IoUtils	Common utilities for working with io.
JavaLexer	Lexer specific for the Java language rules.
JavaScanners
JoinRelation	Models a join.
JoinType	The type of a join.
Keywords	Helper class for creating lexers and parsers for keywords.
LabelStatement	Represents a label statement such as "foo:".
LambdaExpression	Represents lambda expressions.
LambdaExpression.Parameter
Lexicon	A Lexicon is a group of lexical words that can be tokenized by a single tokenizer.
LikeExpression	Represents "expr like 'pattern' escape 'escape'" expression.
ListFactory<T>	Creates a {link List}.
Lists	Internal utility to work with List.
LiteralRule	Represents a literal rule.
Location	Deprecated. Prefer to use SourceLocation instead.
LowerBoundedPattern
LowerBoundWildcard	Represents "? super SomeBound" type literal.
ManyPattern
Map<From,To>	Deprecated. Use Function instead.
Map2<A,B,T>	Deprecated. Use BiFunction instead.
Map3<A,B,C,T>	Maps 3 objects of type A, B and C respectively to an object of type T.
Map4<A,B,C,D,T>	Maps 4 objects of type A, B, C and D respectively to an object of type T.
Map5<A,B,C,D,E,T>	Maps 5 objects of type A, B, C, D and E respectively to an object of type T.
Map6<A,B,C,D,E,F,T>	Maps 6 objects to an object of type T.
Map7<A,B,C,D,E,F,G,T>	Maps 7 objects to an object of type T.
Map8<A,B,C,D,E,F,G,H,T>	Maps 8 objects to an object of type T.
Maps	Provides common implementations of Map interface and the variants.
Member	Represents any class member, interface member, enum member etc.
MethodCallExpression	Represents expressions like obj.f(...).
MethodDef	Represents a method definition.
MethodReference	Represents expressions like obj::f.
Modifier	Represents either a built-in modifier or annotation.
NestableBlockCommentScanner	Parses any nestable comment pattern.
NestedDef	Represents a nested declaration.
NewArrayExpression	Represents a "new Foo[] {...}" or "new Foo[size] {...}" expression.
NewExpression	Represents a non-qualified "new" statement with possibly anonymous class syntax.
NopStatement	Represents the no-op statement ";".
NotPattern
NullExpression	Represents "null".
NullExpression	Represents "null".
NumberExpression	A number expression.
NumberLiteralsTranslator	Transforms the recognized character range to an integer within 64 bits.
NumberType	Distinguishes between "L", "F", "D" and int.
Objects	Utility functions for any object.
ObjectTester	Tests any Object for Object.equals(Object) and Object.hashCode().
ObjectTester.AnotherType
Op	Operators
Operator	Defines operators used in Java.
Operators	Helper class for creating parsers and lexers for operators.
Operators.Suite	A suite is a list of overlapping operators, where some operators are prefixes of other operators.
Operators.Suites	A list of suites in the reverse order of the suites.
OperatorTable<T>	Builds Parser to parse expressions with operator-precedence grammar.
OperatorTable.Associativity	Describes operator associativity, in order of precedence.
OperatorTable.Operator
OptionalPattern
OrderBy	The "order by" clause.
OrderBy.Item
OrPattern
Pair<A,B>	Deprecated. Prefer to using a lambda expression to convert to your own type.
ParameterDef	Represents a parameter definition.
ParseContext	Represents the context state during parsing.
ParseContext.ErrorType
ParseContext.ParserTrace	Allows tracing of parsing progress during error condition, to ease debugging.
ParseErrorDetails	Describes details of a parsing error to support fine-grained error handling.
Parser<T>	Defines grammar and encapsulates parsing logic.
Parser.Mode	Defines the mode that a parser should be run in.
Parser.Reference<T>	An atomic mutable reference to Parser used in recursive grammars.
Parser.Rhs<T>
ParserException	Is thrown when any grammar error happens or any exception is thrown during parsing.
Parsers	Provides common Parser implementations.
ParserState	Represents ParseContext for token level parsing.
ParseTree	Represents the syntactical structure of the input being parsed.
Pattern	Encapsulates algorithm to recognize certain string pattern.
Patterns	Provides common Pattern implementations.
PeekPattern
PostfixUnaryExpression	Represents expression with postfix unary operator.
PrefixUnaryExpression	Represents expression with prefix unary operator.
Private	Annotates anything that should be private but is allowing test cases to access it.
Program	Represents a single java source file.
Projection	Represents a single projection in a select statement, it can be either an expression, a wildcard or an expression with an alias.
QualifiedExpression	Represents "obj.field", "SomeType.staticField", "SomeType.SomeNestedType" or "org.codehaus.jparsec" kind of qualified expressions.
QualifiedName	Represents a qualified name in import or package statement.
QualifiedName	A qualified name like "a.b.c".
QualifiedNameExpression	An expression like "a.b.c".
QuantifiedRule	Represents a quantified rule.
Quantifier	Qualifies a rule.
ReadonlyExpression
Relation	Models a relation such as a select statement, or a table.
RelationParser	Parser for relation.
ReluctantBetweenParser<T>	Deprecated.
RepeatAtLeastParser<T>
RepeatCharPredicatePattern
RepeatPattern
RepeatTimesParser<T>
ReturnStatement	Represents "return" statement.
Rule	Represents any rule in BNF.
RuleDef	Represents a rule definition.
RuleParser	Parser for bnf rules.
RuleReference	Represents a reference to a named production rule.
Scanners	Provides common Parser implementations that scan the source and match certain string patterns.
ScannerState	Parser state for scanner.
ScientificNumberLiteral	Represents scientific notation number.
Select	Models the select statement.
SequencePattern
SequentialRule	Represents a sequential rule.
SimpleCaseExpression	The "case expr when cond then val ... end" expression.
SimpleTypeLiteral	Represents a non-array type literal.
SingleExpression
SkipAtLeastParser
SkipTimesParser
SourceLocation	Represents a location inside the source.
SourceLocator	Locates the line and column number of a 0-based index in the source.
Statement	Represents any statement.
StatementParser	Parses a statement.
StringCase
StringExpression	A string literal.
StringLiteral	Represents a string literal.
StringLiteralsTranslator	Translates the recognized string literal to a String.
Strings	Manipulates String.
Strings	Internal utility for String operation.
SuperCallStatement	Represents a "this(params)" statement.
SuperExpression	Represents the "super" keyword.
SwitchStatement	Represents the "switch case" expression.
SynchronizedBlockStatement	Represents "synchronized" block.
SystemModifier	Represents built in modifiers.
TableRelation	Models a table name.
TerminalParser	Parses terminals in a bnf.
TerminalParser	Parser for terminals.
TerminalParser	Lexers and terminal level parsers for SQL.
Terminals	Provides convenient API to build lexer and parsers for terminals.
Terminals.CharLiteral	Entry point for parser and tokenizers of character literal.
Terminals.DecimalLiteral	Entry point for parser and tokenizers of decimal number literal represented as String.
Terminals.Identifier	Entry point for parser and tokenizers of regular identifier.
Terminals.IntegerLiteral	Entry point for any arbitrary integer literal represented as a String.
Terminals.LongLiteral	Entry point for parser and tokenizers of integral number literal represented as Long.
Terminals.ScientificNumberLiteral	Entry point for parser and tokenizers of scientific notation literal.
Terminals.StringLiteral	Entry point for parser and tokenizers of string literal.
ThisCallStatement	Represents a "this(params)" statement.
ThisExpression	"this" or "A.B.this".
ThrowStatement	Represents a "throw" statement.
Token	Represents any token with a token value and the 0-based index in the source.
TokenizerMaps	Common Function implementations that maps from String.
TokenMap<T>	Maps a Token to a an object of type T, or null if the token isn't recognized.
Tokens	Provides common token values.
Tokens.Fragment	Represents a fragment tagged according to its semantics.
Tokens.ScientificNotation	Represents a scientific notation with a significand (mantissa) and an exponent.
Tokens.Tag	Pre-built Tokens.Fragment token tags.
TreeNode	A TreeNode remembers it's parent (which corresponds to a parent parser that syntactically encloses this parter), it's previous node (which is the parser at the same syntactical level and had just succeeded before this parser started).
TryStatement	Represents the "try-catch-finally" statement.
TryStatement.CatchBlock
Tuple3<A,B,C>	Deprecated. Prefer to using a lambda expression to convert to your own type.
Tuple4<A,B,C,D>	Deprecated. Prefer to using a lambda expression to convert to your own type.
Tuple5<A,B,C,D,E>	Deprecated. Prefer to using a lambda expression to convert to your own type.
TupleExpression	Models a tuple of expressions such as "(1, 2, 3)".
Tuples	Deprecated. Prefer to using a lambda expression to convert to your own type.
TypeLiteral	Represents a type literal.
TypeLiteralParser	Parses any type literal.
TypeParameterDef	Represents a type parameter in a type or method definition.
Unary<T>	Deprecated. Use UnaryOperator instead.
UnaryExpression	Models an expression with unary operator.
UnaryRelationalExpression	Models an expression like "exists (select ...)".
UnionRelation	Models a union relation.
UpperBoundedPattern
UpperBoundWildcard	Represents "? extends SomeBound" type literal.
ValueExpression
ValueObject	Base class that implements Object.equals(Object), Object.hashCode() and Object#toString() on final fields.
VarExpression
VarStatement	Represents a single variable declaration.
VarStatement.Var
WhileStatement	Represents the "while () ..." statement.
WildcardExpression	"a.b.*" or "*".
WithSource<T>	Parsed result with the matched source text.