All Classes

All Classes Interface Summary Class Summary Exception Summary
Class	Description
AbstractMatcher	Abstract base class of most regular `Matcher`s.
AbstractParseRunner<V>
Action<V>	Instances of classes implementing this interface can be used directly in a rule definition to define a parser action.
ActionError	A `ParseError` wrapping an ActionException.
ActionException	Exception that can be thrown by parser actions to signal that an error has occurred that is to be collected in the ParseErrors for the parsing run.
ActionMatcher	A `Matcher` that not actually matches input but runs a given parser `Action`.
AnyMatcher	A `Matcher` matching any single character except EOI.
AnyOfMatcher	A `Matcher` matching a single character out of a given `Characters` set.
ArrayBuilder<T>
Base64
BasicParseError	A basic `ParseError` implementation for a one-char parse error with an optional error message.
BasicParseRunner<V>	The most basic of all `ParseRunner` implementations.
BinaryTreeNode<T extends BinaryTreeNode<T>>	A `TreeNode` specialization with only two child nodes, left and right.
CanMatchEmptyVisitor	A `MatcherVisitor` determining whether a matcher can legally succeed with an empty match.
Characters	An immutable, set-like aggregation of (relatively few) characters that allows for an inverted semantic ("all chars except these few").
CharIgnoreCaseMatcher	A `Matcher` matching a single character case-independently.
CharMatcher	A `Matcher` matching a single given character.
CharRangeMatcher	A `Matcher` matching a single character out of a given range of characters.
Chars
Checks	Utility methods for grammar integrity checks.
ConsoleSink
Context<V>	A Context object is available to parser actions methods during their runtime and provides various support functionalities.
ContextAware<V>	Interface that can be implemented by classes containing action methods.
CustomMatcher	Base class of custom matcher implementations.
DebuggingValueStack<V>
DefaultInputBuffer	Immutable default implementation of an InputBuffer.
DefaultInvalidInputErrorFormatter	A `Formatter` for `InvalidInputError`s that automatically creates the correct "expected" text for the error.
DefaultMatcherVisitor<R>	A basic `MatcherVisitor` implementation that delegates all visiting methods to one default value method.
DefaultValueStack<V>	An implementation of a stack of value objects providing an efficient snapshot capability and a number of convenience methods.
DefaultValueStack.Element
DoWithMatcherVisitor	A MatcherVisitor that executes a given `DoWithMatcherVisitor.Action` against a whole matcher hierarchy in a depth-first manner.
DoWithMatcherVisitor.Action
EmptyMatcher	A `Matcher` that always successfully matches nothing.
ErrorLocatingParseRunner<V>	A `ParseRunner` implementation that creates a simple `BasicParseError` for the first error found in the input and adds it to the list of ParseErrors.
ErrorReportingParseRunner<V>	A `ParseRunner` implementation that creates an `InvalidInputError` for the error at a known error location.
ErrorUtils	General utility methods regarding parse errors.
Factory<T>
FileUtils
Filters
FirstOfMatcher	A `Matcher` trying all of its submatchers in sequence and succeeding when the first submatcher succeeds.
FirstOfStringsMatcher	A specialized FirstOfMatcher that handles FirstOf(string, string, ...) rules much faster that the regular FirstOfMatcher.
FollowMatchersVisitor	Collects the matchers that can legally follow the given matcher according to the grammar into a given list.
Formatter<T>	The capability to transform an object of type T into a string representation.
GetStarterCharVisitor	Returns the first character a given matcher can start a match with.
GrammarException	Exception thrown by parboiled if a problem with the integrity of the grammar rules has been detected.
GraphNode<T extends GraphNode<T>>	A node in a directed graph (that may have cycles).
GraphUtils	General utility methods for operating on directed graphs (consisting of `GraphNode`s).
IllegalIndentationException	Exception thrown by the IndentDedentInputbuffer upon detection of an illegal indentation.
ImmutableBinaryTreeNode<T extends BinaryTreeNode<T>>	A simple immutable implementation of the `BinaryTreeNode` interface.
ImmutableGraphNode<T extends GraphNode<T>>	A simple, immutable `GraphNode` implementation.
ImmutableLinkedList<T>
ImmutableList<T>	A simple, immutable List implementation wrapping an array.
ImmutableTreeNode<T extends TreeNode<T>>	An `ImmutableGraphNode` specialization representing a tree node with a parent field linking back to the nodes (only) parent.
IndentDedentInputBuffer	Special, immutable InputBuffer implementation for indentation based grammars.
IndexRange	A simple immutable container for a range of indices into an underlying InputBuffer.
InputBuffer	Abstraction of a simple char[] buffer holding the input text to be parsed.
InputBufferUtils
IntArrayStack
IntArrayStack.UnderflowException
InvalidInputError	A `ParseError` describing one or more input characters that are illegal with regard to the underlying language grammar.
IsSingleCharMatcherVisitor	A `MatcherVisitor` determining whether a matcher is a basic single character matcher.
IsStarterCharVisitor	A `MatcherVisitor` determining whether a matcher can start a match with a given char.
LabelPrefixPredicate<V>	A simple Node predicate determining whether a Node matches a given label prefix.
Matcher	A Matcher instance is responsible for "executing" a specific Rule instance, i.e.
MatcherContext<V>	The Context implementation orchestrating most of the matching process.
MatcherPath	Holds a snapshot of the current `Matcher` stack at a certain point during the parsing process.
MatcherPath.Element
MatcherPosition
MatcherUtils
MatcherVisitor<R>	The interface to be implemented by all visitors of `Matcher`s.
MatchHandler	A MatchHandler is responsible for actually running the match of a given `MatcherContext`.
MemoMismatchesMatcher	Special wrapping matcher that performs memoization of the last mismatch of the wrapped sub rule.
MutableBinaryTreeNode<T extends MutableBinaryTreeNode<T>>	A `MutableTreeNode` specialization also satisfying the `BinaryTreeNode` interface and providing mutability methods.
MutableBinaryTreeNodeImpl<T extends MutableBinaryTreeNode<T>>	A simple `MutableBinaryTreeNode` implementation based on the `MutableTreeNodeImpl`.
MutableInputBuffer	An InputBuffer wrapping another InputBuffer and providing for the ability to insert (and undo) characters at certain index positions.
MutableTreeNode<T extends MutableTreeNode<T>>	A `TreeNode` specialiation that allow for mutability of the tree structure.
MutableTreeNodeImpl<T extends MutableTreeNode<T>>	A base implementation of the `MutableTreeNode`.
Node<V>	Represents a node in the parse tree created during a parsing run.
NodeFormatter<V>	A simple Formatter that provides String representation for parse tree nodes.
NothingMatcher	A `Matcher` that never matches anything.
OneOrMoreMatcher	A `Matcher` that repeatedly tries its submatcher against the input.
OptionalMatcher	A `Matcher` that tries its submatcher once against the input and always succeeds.
ParseError	Common interface of all parboiled parse error implementations.
ParserRuntimeException	Exception that is thrown for any problem during the parsing run that cannot be overcome automatically.
ParserStatistics
ParseRunner<V>	A ParseRunner performs the actual parsing run of a given parser rule on a given input text.
ParseTreeUtils	General utility methods for operating on parse trees.
ParsingException	Exception type not directly used by parboiled but included as a convenience base class for custom exceptions (or to be used directly if no custom exception types are required).
ParsingResult<V>	A simple container encapsulating the result of a parsing run.
Position	Simple container class for a line/column position in the input text.
Preconditions	Simple static methods to be called at the start of your own methods to verify correct arguments and state.
Predicate<T>
Predicates
ProfilingParseRunner<V>	The ProfilingParseRunner is a special `ParseRunner` implementation that "watches" a parser digest a number of inputs and collects all sorts of statistical data on the what rules have matched how many times, the number of reincovations of rules at identical input locations, and so on.
ProfilingParseRunner.Report
ProfilingParseRunner.RuleReport
ProxyMatcher	A `Matcher` that delegates all `Rule` and `Matcher` interface methods to another `Matcher`.
RecoveringParseRunner<V>	A `ParseRunner` implementation that is able to recover from `InvalidInputError`s in the input and therefore report more than just the first `InvalidInputError` if the input does not conform to the rule grammar.
RecoveringParseRunner.TimeoutException
Reference<T>	A simple container holding a reference to another object.
ReportingParseRunner<V>	A `ParseRunner` implementation that properly reports the first `InvalidInputError` if the input does not conform to the rule grammar.
Rule	Describes the return values of parser rule production methods.
SequenceMatcher	A `Matcher` that executes all of its submatchers in sequence and only succeeds if all submatchers succeed.
Sink<T>
SkippableAction<V>	An action that can optionally be skipped when run underneath a predicate matcher.
StringBuilderSink
StringBuilderVar	Simple specialization of a `Var` for StringBuilders.
StringMatcher	A `SequenceMatcher` specialization for sequences of CharMatchers.
StringUtils	General utility methods for string manipulation.
StringVar	Simple specialization of a `Var` for Strings.
TestMatcher	A special `Matcher` not actually matching any input but rather trying its submatcher against the current input position.
TestNotMatcher	A special `Matcher` not actually matching any input but rather trying its submatcher against the current input position.
ToStringFormatter<T>	A simple Formatter falling back to the objects toString() method.
TracingParseRunner<V>	A `ParseRunner` implementation used for debugging purposes.
TreeNode<T extends TreeNode<T>>	A specialization of a `GraphNode` that contains a reference to its parent, thereby making the graph a tree (since each node can now have only one parent node).
TreeUtils	General utility methods for operating on tree, i.e.
Tuple2<A,B>
Tuple3<A,B,C>
Utils	General utility methods.
ValueStack<V>	A ValueStack is a stack implementation for parser values.
Var<T>	This class provides a "local variable"-like construct for action expressions in parser rule methods.
VarFramingMatcher	Special wrapping matcher that manages the creation and destruction of execution frames for a number of action vars.
ZeroOrMoreMatcher	A `Matcher` that repeatedly tries its submatcher against the input.