Uses of Class
com.google.common.labs.parse.Parser

Packages that use Parser

Package	Description
com.google.common.labs.email	A strict, i18n-compliant email address parser (requires dot-parse artifact)
com.google.common.labs.parse	Parser combinator that's free from infinite loop or accidental left recursion (requires dot-parse artifact)

Uses of Parser in com.google.common.labs.email

Fields in com.google.common.labs.email declared as Parser

Modifier and Type	Field	Description
static final Parser<EmailAddress>	EmailAddress.PARSER	The parser for email address, according to RFC 5322, and supporting BMP characters.

Uses of Parser in com.google.common.labs.parse

Subclasses of Parser in com.google.common.labs.parse

Modifier and Type	Class	Description
static final class	Parser.Rule<T>	A forward-declared production rule, to be used for recursive grammars.

Methods in com.google.common.labs.parse that return Parser

Modifier and Type	Method	Description
static <T> Parser<T>	Parser.anyOf(Parser<? extends T>... parsers)	Matches if any of the given parsers match.
static <T extends Enum<?>> Parser<T>	Parser.anyOf(T... values)	Returns a parser that matches any of the given enum values by their Enum.toString().
final Parser<List<T>>	Parser.atLeastOnce()	Returns a parser that applies this parser at least once, greedily.
final Parser<T>	Parser.atLeastOnce(BinaryOperator<T> reducer)	Returns a parser that applies this parser at least once, greedily, and reduces the results using the reducer function.
final <A,R> Parser<R>	Parser.atLeastOnce(Collector<? super T, A, ? extends R> collector)	Returns a parser that applies this parser at least once, greedily, and collects the return values using collector.
final <A,R> Parser<R>	Parser.atLeastOnceDelimitedBy(Parser<?> delimiter, Collector<? super T, A, ? extends R> collector)	Returns a parser that matches this pattern at least once, delimited by the given delimiter.
final Parser<List<T>>	Parser.atLeastOnceDelimitedBy(String delimiter)	Returns a parser that matches this pattern at least once, delimited by the given delimiter.
final Parser<T>	Parser.atLeastOnceDelimitedBy(String delimiter, BinaryOperator<T> reducer)	Returns a parser that matches this pattern at least once, delimited by the given delimiter, using the given reducer function to reduce the results.
final <A,R> Parser<R>	Parser.atLeastOnceDelimitedBy(String delimiter, Collector<? super T, A, ? extends R> collector)	Returns a parser that matches this pattern at least once, delimited by the given delimiter.
final Parser<T>	Parser.between(Parser<?>.OrEmpty prefix, Parser<?>.OrEmpty suffix)	Returns a parser that matches this pattern enclosed between prefix and suffix, both allowed to be empty.
default Parser<T>	Production.between(Parser<?>.OrEmpty prefix, Parser<?> suffix)	The current production must be enclosed between prefix that may be empty and suffix that may not be empty.
default Parser<T>	Production.between(Parser<?> prefix, Parser<?> suffix)	The current production must be enclosed between non-empty prefix and suffix.
default Parser<T>	Production.between(Parser<?> prefix, Parser<?>.OrEmpty suffix)	The current production must be enclosed between non-empty prefix and suffix that may be empty.
default Parser<T>	Production.between(String prefix, String suffix)	The current production must be enclosed between non-empty prefix and suffix.
static Parser<Integer>	Parser.bmpCodeUnit()	Parses a 4-digit hex BMP code unit.
Parser<T>	OperatorTable.build(Parser<? extends T> operand)	Builds a parser with the configured operators applied to the given operand.
static Parser<?>	Parser.caseInsensitive(String string)	Matches a literal string case insensitively.
static Parser<?>	Parser.caseInsensitiveWord(String word)	caseInsensitiveWord("or") matches "Or" and "OR", but not "orange".
static Parser<String>	Parser.chars(int n)	Consumes exactly n consecutive characters.
static Parser<String>	Parser.consecutive(CharacterSet characterSet)	Matches one or more consecutive characters contained in characterSet.
static Parser<String>	Parser.consecutive(CharPredicate matcher, String name)	Matches one or more consecutive characters as specified by matcher.
static <T> Parser<T>	Parser.define(Function<? super Parser<T>, ? extends Parser<? extends T>> definition)	Defines a simple recursive grammar without needing to explicitly forward-declare a Parser.Rule.
<S extends T> Parser<S>	Parser.Rule.definedAs(Parser<S> parser)	Define this rule as parser and returns it.
static Parser<String>	Parser.digits()	One or more regex \d+ characters.
static Parser<String>	Parser.first(String target)	Returns a parser that finds the first literal string that may start from the current position or after any number of characters.
final <R> Parser<R>	Parser.flatMap(Function<? super T, ? extends Production<? extends R>> f)	If this parser matches, applies function f to get the next production rule to match in sequence.
Parser<T>	Parser.followedBy(Parser<?> suffix)
final <S> Parser<T>	Parser.followedBy(Parser<S>.OrEmpty suffix)
Parser<T>	Parser.OrEmpty.followedBy(Parser<?> suffix)
Parser<T>	Production.followedBy(Parser<?> suffix)	The current production must be followed by non-empty suffix.
default Parser<T>	Production.followedBy(String suffix)	The current production must be followed by non-empty suffix.
final Parser<T>	Parser.followedByOrEof(Parser<?> suffix)	Specifies that the matched pattern must be either followed by suffix or EOF.
default Parser<T>	Production.immediatelyBetween(String prefix, String suffix)	The current production must be immediately enclosed between non-empty prefix and suffix (no skippable characters as specified by parseSkipping() in between).
static <T> Parser<T>	Parser.literally(Parser<T> parser)	Returns an equivalent parser that suppresses character skipping that's otherwise applied if parseSkipping() or skipping() are called.
final <R> Parser<R>	Parser.map(Function<? super T, ? extends R> f)	If this parser matches, returns the result of applying the given function to the match.
Parser<T>	Parser.OrEmpty.notEmpty()	Returns the otherwise equivalent Parser that will fail instead of returning the default value if empty.
final Parser<T>	Parser.notFollowedBy(Parser<?> suffix, String name)	A form of negative lookahead such that the match is rejected if followed by suffix.
final Parser<T>	Parser.notFollowedBy(String suffix)	A form of negative lookahead such that the match is rejected if followed by suffix.
final Parser<T>	Parser.notImmediatelyFollowedBy(CharPredicate predicate, String name)	A form of negative lookahead such that the match is rejected if immediately followed by (no skippable characters as specified by parseSkipping() in between) a character that matches predicate.
static Parser<Character>	Parser.one(char c)	Matches the given character c.
static Parser<Character>	Parser.one(CharacterSet characterSet)	Matches a character in characterSet.
static Parser<Character>	Parser.one(CharPredicate matcher, String name)	Matches a character as specified by matcher.
final <S> Parser<T>	Parser.optionallyFollowedBy(Parser<S> suffix, BiFunction<? super T, ? super S, ? extends T> op)	If this parser matches, optionally matches suffix with the op BiFunction to transform the current parser's result.
final Parser<T>	Parser.optionallyFollowedBy(String suffix)
final Parser<T>	Parser.optionallyFollowedBy(String suffix, Function<? super T, ? extends T> op)
final Parser<T>	Parser.or(Parser<? extends T> that)	Matches if this or that matches.
static Parser<String>	Parser.quotedBy(char before, char after)	Matches the characters quoted by before and after, and returns the string in between.
static Parser<String>	Parser.quotedBy(String before, String after)	Matches the characters quoted by before and after, and returns the string in between.
static Parser<String>	Parser.quotedByWithEscapes(char before, char after, Parser<? extends CharSequence> escaped)	String literal quoted by before and after with backslash escapes.
static Parser<String>	Parser.quotedByWithEscapes(String before, char after, Parser<? extends CharSequence> escaped)	String literal quoted by before and after with backslash escapes.
static <A,B,R> Parser<R>	Parser.sequence(Parser<A>.OrEmpty left, Parser<B> right, BiFunction<? super A, ? super B, ? extends R> combiner)	Sequentially matches left (which is allowed to be optional), then right, and then combines the results using the combiner function.
static <A,B,R> Parser<R>	Parser.sequence(Parser<A> left, Parser<B> right, BiFunction<? super A, ? super B, ? extends R> combiner)	Sequentially matches left then right, and then combines the results using the combiner function.
static <A,B,C,D,R> Parser<R>	Parser.sequence(Parser<A> a, Production<B> b, Production<C> c, Production<D> d, Function4<? super A, ? super B, ? super C, ? super D, ? extends R> combiner)	Sequentially matches a, b, c and d, and then combines the results using the combiner function.
static <A,B,C,R> Parser<R>	Parser.sequence(Parser<A> a, Production<B> b, Production<C> c, TriFunction<? super A, ? super B, ? super C, ? extends R> combiner)	Sequentially matches a, b and c, and then combines the results using the combiner function.
static <A,B,R> Parser<R>	Parser.sequence(Parser<A> left, Production<B> right, BiFunction<? super A, ? super B, ? extends R> combiner)	Sequentially matches left then right, and then combines the results using the combiner function.
final Parser<String>	Parser.source()	Returns a parser that matches this pattern and returns the matched string.
static Parser<String>	Parser.string(String string)	Matches a literal string.
final Parser<T>	Parser.suchThat(Predicate<? super T> condition, String name)	If this parser matches, applies the given condition and disqualifies the match if the condition is false.
<S> Parser<S>	Parser.OrEmpty.then(Parser<S> suffix)
final <R> Parser<R>	Parser.then(Parser<R>.OrEmpty suffix)	If this parser matches, applies the given optional (or zero-or-more) parser on the remaining input.
final <S> Parser<S>	Parser.then(Parser<S> suffix)
<S> Parser<S>	Production.then(Parser<S> suffix)	After matching the current production, proceed to match suffix.
final <R> Parser<R>	Parser.thenReturn(R result)	If this parser matches, returns the given result.
final Parser<T>	Parser.withPostfixes(Parser<? extends UnaryOperator<T>> operator)	Returns a parser that after this parser succeeds, applies the operator parser zero or more times and applies the result unary operator function iteratively.
final <S> Parser<T>	Parser.withPostfixes(Parser<S> operator, BiFunction<? super T, ? super S, ? extends T> postfixFunction)	Returns a parser that after this parser succeeds, applies the operator parser zero or more times and applies the result unary operator function iteratively.
final Parser<T>	Parser.withPostfixes(String operator, UnaryOperator<T> postfixFunction)	Returns a parser that after this parser succeeds, applies the operator parser zero or more times and applies the result unary operator function iteratively.
final Parser<T>	Parser.withPrefixes(Parser<? extends UnaryOperator<T>> operator)	Returns a parser that applies the operator parser zero or more times before this and applies the result unary operator functions iteratively.
static Parser<String>	Parser.word()	One or more regex \w+ characters.
static Parser<String>	Parser.word(String word)	word("or") matches "or" but not "orange".

Methods in com.google.common.labs.parse that return types with arguments of type Parser

Modifier and Type	Method	Description
static <T> Collector<Parser<? extends T>, ?, Parser<T>>	Parser.or()	Returns a collector that results in a parser that matches if any of the input parsers match.
static <T> Collector<Parser<? extends T>, ?, Parser<T>>	Parser.or()	Returns a collector that results in a parser that matches if any of the input parsers match.

Methods in com.google.common.labs.parse with parameters of type Parser

Modifier and Type	Method	Description
static <T> Parser<T>	Parser.anyOf(Parser<? extends T>... parsers)	Matches if any of the given parsers match.
final <A,R> Parser<R>	Parser.atLeastOnceDelimitedBy(Parser<?> delimiter, Collector<? super T, A, ? extends R> collector)	Returns a parser that matches this pattern at least once, delimited by the given delimiter.
default Parser<T>	Production.between(Parser<?>.OrEmpty prefix, Parser<?> suffix)	The current production must be enclosed between prefix that may be empty and suffix that may not be empty.
default Parser<T>	Production.between(Parser<?> prefix, Parser<?> suffix)	The current production must be enclosed between non-empty prefix and suffix.
default Parser<T>	Production.between(Parser<?> prefix, Parser<?>.OrEmpty suffix)	The current production must be enclosed between non-empty prefix and suffix that may be empty.
Parser<T>	OperatorTable.build(Parser<? extends T> operand)	Builds a parser with the configured operators applied to the given operand.
<S extends T> Parser<S>	Parser.Rule.definedAs(Parser<S> parser)	Define this rule as parser and returns it.
Parser<T>	Parser.followedBy(Parser<?> suffix)
Parser<T>	Parser.OrEmpty.followedBy(Parser<?> suffix)
Parser<T>	Production.followedBy(Parser<?> suffix)	The current production must be followed by non-empty suffix.
final Parser<T>	Parser.followedByOrEof(Parser<?> suffix)	Specifies that the matched pattern must be either followed by suffix or EOF.
OperatorTable<T>	OperatorTable.leftAssociative(Parser<? extends BinaryOperator<T>> operator, int precedence)	Adds a left-associative infix operator with the given precedence to the table.
static <T> Parser<T>	Parser.literally(Parser<T> parser)	Returns an equivalent parser that suppresses character skipping that's otherwise applied if parseSkipping() or skipping() are called.
OperatorTable<T>	OperatorTable.nonAssociative(Parser<? extends BinaryOperator<T>> operator, int precedence)	Adds a non-associative infix operator (e.g.
final Parser<T>	Parser.notFollowedBy(Parser<?> suffix, String name)	A form of negative lookahead such that the match is rejected if followed by suffix.
final <S> Parser<T>	Parser.optionallyFollowedBy(Parser<S> suffix, BiFunction<? super T, ? super S, ? extends T> op)	If this parser matches, optionally matches suffix with the op BiFunction to transform the current parser's result.
final <S> Parser<T>.OrEmpty	Parser.OrEmpty.optionallyFollowedBy(Parser<S> suffix, BiFunction<? super T, ? super S, ? extends T> op)	If this parser matches, optionally matches suffix with the op BiFunction to transform the current parser's result.
<S> Production<T>	Production.optionallyFollowedBy(Parser<S> suffix, BiFunction<? super T, ? super S, ? extends T> op)	If this production rule matches, optionally matches suffix with the op BiFunction to transform the current production's result.
final Parser<T>	Parser.or(Parser<? extends T> that)	Matches if this or that matches.
T	Parser.OrEmpty.parseSkipping(Parser<?> skip, String input)	Parses the entire input string, ignoring patterns matched by skip, and returns the result; if there's nothing to parse except skippable content, returns the default empty value.
final T	Parser.parseSkipping(Parser<?> skip, String input)	Parses input while skipping patterns matched by skip around atomic matches.
T	Production.parseSkipping(Parser<?> skip, String input)	Parses the entire input string, ignoring patterns matched by skip, and returns the result.
OperatorTable<T>	OperatorTable.postfix(Parser<? extends UnaryOperator<T>> operator, int precedence)	Adds a postfix operator with the given precedence to the table.
<S> OperatorTable<T>	OperatorTable.postfix(Parser<S> operator, BiFunction<? super T, ? super S, ? extends T> postfixFunction, int precedence)	Adds a postfix operator with the given precedence to the table.
OperatorTable<T>	OperatorTable.prefix(Parser<? extends UnaryOperator<T>> operator, int precedence)	Adds a prefix operator with the given precedence to the table.
static Parser<String>	Parser.quotedByWithEscapes(char before, char after, Parser<? extends CharSequence> escaped)	String literal quoted by before and after with backslash escapes.
static Parser<String>	Parser.quotedByWithEscapes(String before, char after, Parser<? extends CharSequence> escaped)	String literal quoted by before and after with backslash escapes.
OperatorTable<T>	OperatorTable.rightAssociative(Parser<? extends BinaryOperator<T>> operator, int precedence)	Adds a right-associative infix operator with the given precedence to the table.
static <A,B,R> Parser<R>	Parser.sequence(Parser<A>.OrEmpty left, Parser<B> right, BiFunction<? super A, ? super B, ? extends R> combiner)	Sequentially matches left (which is allowed to be optional), then right, and then combines the results using the combiner function.
static <A,B,R> Parser<R>	Parser.sequence(Parser<A> left, Parser<B> right, BiFunction<? super A, ? super B, ? extends R> combiner)	Sequentially matches left then right, and then combines the results using the combiner function.
static <A,B,C,D,R> Parser<R>	Parser.sequence(Parser<A> a, Production<B> b, Production<C> c, Production<D> d, Function4<? super A, ? super B, ? super C, ? super D, ? extends R> combiner)	Sequentially matches a, b, c and d, and then combines the results using the combiner function.
static <A,B,C,R> Parser<R>	Parser.sequence(Parser<A> a, Production<B> b, Production<C> c, TriFunction<? super A, ? super B, ? super C, ? extends R> combiner)	Sequentially matches a, b and c, and then combines the results using the combiner function.
static <A,B,R> Parser<R>	Parser.sequence(Parser<A> left, Production<B> right, BiFunction<? super A, ? super B, ? extends R> combiner)	Sequentially matches left then right, and then combines the results using the combiner function.
final Parser<T>.Lexical	Parser.skipping(Parser<?> skip)	Starts a fluent chain for parsing inputs while skipping patterns matched by skip.
<S> Parser<S>	Parser.OrEmpty.then(Parser<S> suffix)
final <S> Parser<S>	Parser.then(Parser<S> suffix)
<S> Parser<S>	Production.then(Parser<S> suffix)	After matching the current production, proceed to match suffix.
final Parser<T>	Parser.withPostfixes(Parser<? extends UnaryOperator<T>> operator)	Returns a parser that after this parser succeeds, applies the operator parser zero or more times and applies the result unary operator function iteratively.
final <S> Parser<T>	Parser.withPostfixes(Parser<S> operator, BiFunction<? super T, ? super S, ? extends T> postfixFunction)	Returns a parser that after this parser succeeds, applies the operator parser zero or more times and applies the result unary operator function iteratively.
final Parser<T>	Parser.withPrefixes(Parser<? extends UnaryOperator<T>> operator)	Returns a parser that applies the operator parser zero or more times before this and applies the result unary operator functions iteratively.
static <A,B,R> Parser<R>.OrEmpty	Parser.zeroOrMoreDelimited(Parser<A> first, Production<B> second, String delimiter, BiCollector<? super A, ? super B, R> collector)	Applies first and the optional second pattern in order, for zero or more times, collecting the results using the provided BiCollector.
final <A,R> Parser<R>.OrEmpty	Parser.zeroOrMoreDelimitedBy(Parser<?> delimiter, Collector<? super T, A, ? extends R> collector)	Starts a fluent chain for matching the current parser zero or more times, delimited by delimiter.

Method parameters in com.google.common.labs.parse with type arguments of type Parser

Modifier and Type	Method	Description
static <T> Parser<T>	Parser.define(Function<? super Parser<T>, ? extends Parser<? extends T>> definition)	Defines a simple recursive grammar without needing to explicitly forward-declare a Parser.Rule.
static <T> Parser<T>	Parser.define(Function<? super Parser<T>, ? extends Parser<? extends T>> definition)	Defines a simple recursive grammar without needing to explicitly forward-declare a Parser.Rule.