java.lang.Object
- org.jparsec.Parsers

public final class Parsers
extends java.lang.Object

Provides common Parser implementations.

Field Summary

Fields
Modifier and Type	Field	Description
`private static Parser`	`ALWAYS`
`static Parser<java.lang.Object>`	`ANY_TOKEN`	A `Parser` that consumes a token.
`static Parser<?>`	`EOF`	`Parser` that succeeds only if EOF is met.
`(package private) static Parser<java.lang.Boolean>`	`FALSE`
`static Parser<java.lang.Integer>`	`INDEX`	Deprecated. Use `SOURCE_LOCATION` instead.
`private static Parser`	`NEVER`
`static Parser<SourceLocation>`	`SOURCE_LOCATION`	A `Parser` that returns the current location in the source.
`(package private) static Parser<java.lang.Boolean>`	`TRUE`

Constructor Summary

Constructors
Modifier Constructor Description

private Parsers()

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`private static Parser<java.lang.Object>`	`alt(Parser<?>... alternatives)`	Allows the overloads of "or()" to call the varargs version of "or" with no ambiguity.
`static <T> Parser<T>`	`always()`	`Parser` that always succeeds.
`static Parser<java.lang.Object[]>`	`array(Parser<?>... parsers)`	A `Parser` that sequentially runs `parsers` one by one and collects the return values in an array.
`static <T> Parser<T>`	`between(Parser<?> before, Parser<T> parser, Parser<?> after)`	Equivalent to `Parser.between(Parser, Parser)`.
`static <T> Parser<T>`	`constant(T v)`	A `Parser` that always returns `v` regardless of input.
`(package private) static Parser<?>`	`eof(java.lang.String message)`	A `Parser` that succeeds only if EOF is met.
`static <T> Parser<T>`	`expect(java.lang.String name)`	A `Parser` that fails and reports that `name` is logically expected.
`static <T> Parser<T>`	`fail(java.lang.String message)`	A `Parser` that always fails with `message`.
`static <T> Parser<java.util.List<T>>`	`list(java.lang.Iterable<? extends Parser<? extends T>> parsers)`	A `Parser` that sequentially runs `parsers` one by one and collects the return values in a `List`.
`static <T> Parser<T>`	`longer(Parser<? extends T> p1, Parser<? extends T> p2)`	A `Parser` that runs both `p1` and `p2` and selects the longer match.
`static <T> Parser<T>`	`longest(java.lang.Iterable<? extends Parser<? extends T>> parsers)`	A `Parser` that runs every element of `parsers` and selects the longest match.
`static <T> Parser<T>`	`longest(Parser<? extends T>... parsers)`	A `Parser` that runs every element of `parsers` and selects the longest match.
`(package private) static <T> Parser<T>`	`nested(Parser<Token[]> lexer, Parser<? extends T> parser)`	A `Parser` that takes as input the array of `Token` returned from `lexer`, and feeds the tokens as input into `parser`.
`static <T> Parser<T>`	`never()`	`Parser` that always fails.
`static <T> Parser<T>`	`or(java.lang.Iterable<? extends Parser<? extends T>> alternatives)`	A `Parser` that tries each alternative parser in `alternatives`.
`static <T> Parser<T>`	`or(Parser<? extends T>... alternatives)`	A `Parser` that tries each alternative parser in `alternatives`.
`static <T> Parser<T>`	`or(Parser<? extends T> p1, Parser<? extends T> p2)`	A `Parser` that tries 2 alternative parser objects.
`static <T> Parser<T>`	`or(Parser<? extends T> p1, Parser<? extends T> p2, Parser<? extends T> p3)`	A `Parser` that tries 3 alternative parser objects.
`static <T> Parser<T>`	`or(Parser<? extends T> p1, Parser<? extends T> p2, Parser<? extends T> p3, Parser<? extends T> p4)`	A `Parser` that tries 4 alternative parser objects.
`static <T> Parser<T>`	`or(Parser<? extends T> p1, Parser<? extends T> p2, Parser<? extends T> p3, Parser<? extends T> p4, Parser<? extends T> p5)`	A `Parser` that tries 5 alternative parser objects.
`static <T> Parser<T>`	`or(Parser<? extends T> p1, Parser<? extends T> p2, Parser<? extends T> p3, Parser<? extends T> p4, Parser<? extends T> p5, Parser<? extends T> p6)`	A `Parser` that tries 6 alternative parser objects.
`static <T> Parser<T>`	`or(Parser<? extends T> p1, Parser<? extends T> p2, Parser<? extends T> p3, Parser<? extends T> p4, Parser<? extends T> p5, Parser<? extends T> p6, Parser<? extends T> p7)`	A `Parser` that tries 7 alternative parser objects.
`static <T> Parser<T>`	`or(Parser<? extends T> p1, Parser<? extends T> p2, Parser<? extends T> p3, Parser<? extends T> p4, Parser<? extends T> p5, Parser<? extends T> p6, Parser<? extends T> p7, Parser<? extends T> p8)`	A `Parser` that tries 8 alternative parser objects.
`static <T> Parser<T>`	`or(Parser<? extends T> p1, Parser<? extends T> p2, Parser<? extends T> p3, Parser<? extends T> p4, Parser<? extends T> p5, Parser<? extends T> p6, Parser<? extends T> p7, Parser<? extends T> p8, Parser<? extends T> p9)`	A `Parser` that tries 9 alternative parser objects.
`static <A,B> Parser<Pair<A,B>>`	`pair(Parser<? extends A> p1, Parser<? extends B> p2)`	Deprecated. Prefer to converting to your own object with a lambda.
`static Parser<?>`	`runnable(java.lang.Runnable runnable)`	Deprecated.
`static Parser<java.lang.Object>`	`sequence(java.lang.Iterable<? extends Parser<?>> parsers)`	A `Parser` that runs `parsers` sequentially and discards the return values.
`static Parser<java.lang.Object>`	`sequence(Parser<?>... parsers)`	A `Parser` that runs `parsers` sequentially and discards the return values.
`static <T> Parser<T>`	`sequence(Parser<?> p1, Parser<?> p2, Parser<?> p3, Parser<?> p4, Parser<T> p5)`	A `Parser` that runs 5 parser objects sequentially.
`static <T> Parser<T>`	`sequence(Parser<?> p1, Parser<?> p2, Parser<?> p3, Parser<T> p4)`	A `Parser` that runs 4 parser objects sequentially.
`static <T> Parser<T>`	`sequence(Parser<?> p1, Parser<?> p2, Parser<T> p3)`	A `Parser` that runs 3 parser objects sequentially.
`static <T> Parser<T>`	`sequence(Parser<?> p1, Parser<T> p2)`	A `Parser` that runs 2 parser objects sequentially.
`static <A,B,T> Parser<T>`	`sequence(Parser<A> p1, Parser<B> p2, java.util.function.BiFunction<? super A,? super B,? extends T> map)`	A `Parser` that runs `p1` and `p2` sequentially and transforms the return values using `map`.
`static <A,B,C,T> Parser<T>`	`sequence(Parser<A> p1, Parser<B> p2, Parser<C> p3, Map3<? super A,? super B,? super C,? extends T> map)`	A `Parser` that runs 3 parser objects sequentially and transforms the return values using `map`.
`static <A,B,C,D,T> Parser<T>`	`sequence(Parser<A> p1, Parser<B> p2, Parser<C> p3, Parser<D> p4, Map4<? super A,? super B,? super C,? super D,? extends T> map)`	A `Parser` that runs 4 parser objects sequentially and transforms the return values using `map`.
`static <A,B,C,D,E,T> Parser<T>`	`sequence(Parser<A> p1, Parser<B> p2, Parser<C> p3, Parser<D> p4, Parser<E> p5, Map5<? super A,? super B,? super C,? super D,? super E,? extends T> map)`	A `Parser` that runs 5 parser objects sequentially and transforms the return values using `map`.
`static <A,B,C,D,E,F,T> Parser<T>`	`sequence(Parser<A> p1, Parser<B> p2, Parser<C> p3, Parser<D> p4, Parser<E> p5, Parser<F> p6, Map6<? super A,? super B,? super C,? super D,? super E,? super F,? extends T> map)`	A `Parser` that runs 6 parser objects sequentially and transforms the return values using `map`.
`static <A,B,C,D,E,F,G,T> Parser<T>`	`sequence(Parser<A> p1, Parser<B> p2, Parser<C> p3, Parser<D> p4, Parser<E> p5, Parser<F> p6, Parser<G> p7, Map7<? super A,? super B,? super C,? super D,? super E,? super F,? super G,? extends T> map)`	A `Parser` that runs 7 parser objects sequentially and transforms the return values using `map`.
`static <A,B,C,D,E,F,G,H,T> Parser<T>`	`sequence(Parser<A> p1, Parser<B> p2, Parser<C> p3, Parser<D> p4, Parser<E> p5, Parser<F> p6, Parser<G> p7, Parser<H> p8, Map8<? super A,? super B,? super C,? super D,? super E,? super F,? super G,? super H,? extends T> map)`	A `Parser` that runs 7 parser objects sequentially and transforms the return values using `map`.
`static <T> Parser<T>`	`shorter(Parser<? extends T> p1, Parser<? extends T> p2)`	A `Parser` that runs both `p1` and `p2` and selects the shorter match.
`static <T> Parser<T>`	`shortest(java.lang.Iterable<? extends Parser<? extends T>> parsers)`	A `Parser` that runs every element of `parsers` and selects the shortest match.
`static <T> Parser<T>`	`shortest(Parser<? extends T>... parsers)`	A `Parser` that runs every element of `parsers` and selects the shortest match.
`(package private) static <T> Parser<T>[]`	`toArray(java.lang.Iterable<? extends Parser<? extends T>> parsers)`	We always convert `Iterable` to an array to avoid the cost of creating a new object each time the parser runs.
`private static <T> Parser<T>[]`	`toArray(java.util.Collection<? extends Parser<? extends T>> parsers)`
`(package private) static <T> Parser<T>[]`	`toArrayWithIteration(java.lang.Iterable<? extends Parser<? extends T>> parsers)`
`static <T> Parser<T>`	`token(TokenMap<? extends T> fromToken)`	Checks the current token with the `fromToken` object.
`(package private) static Parser<Token[]>`	`tokens(Parser<? extends java.util.Collection<Token>> parser)`	Converts a parser of a collection of `Token` to a parser of an array of `Token`.
`static <T> Parser<T>`	`tokenType(java.lang.Class<? extends T> type, java.lang.String name)`	Checks whether the current token value is of `type`, in which case, the token value is returned and parse succeeds.
`static <A,B> Parser<Pair<A,B>>`	`tuple(Parser<? extends A> p1, Parser<? extends B> p2)`	Deprecated. Prefer to converting to your own object with a lambda.
`static <A,B,C> Parser<Tuple3<A,B,C>>`	`tuple(Parser<? extends A> p1, Parser<? extends B> p2, Parser<? extends C> p3)`	Deprecated. Prefer to converting to your own object with a lambda.
`static <A,B,C,D> Parser<Tuple4<A,B,C,D>>`	`tuple(Parser<? extends A> p1, Parser<? extends B> p2, Parser<? extends C> p3, Parser<? extends D> p4)`	Deprecated. Prefer to converting to your own object with a lambda.
`static <A,B,C,D,E> Parser<Tuple5<A,B,C,D,E>>`	`tuple(Parser<? extends A> p1, Parser<? extends B> p2, Parser<? extends C> p3, Parser<? extends D> p4, Parser<? extends E> p5)`	Deprecated. Prefer to converting to your own object with a lambda.
`static <T> Parser<T>`	`unexpected(java.lang.String name)`	A `Parser` that fails and reports that `name` is logically unexpected.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- EOF
```
public static final Parser<?> EOF
```
  Parser that succeeds only if EOF is met. Fails otherwise.
- ANY_TOKEN
```
public static final Parser<java.lang.Object> ANY_TOKEN
```
  A Parser that consumes a token. The token value is returned from the parser.
- INDEX
```
@Deprecated
public static final Parser<java.lang.Integer> INDEX
```
  Deprecated.
  Use SOURCE_LOCATION instead.
  
  A Parser that retrieves the current index in the source.
- SOURCE_LOCATION
```
public static final Parser<SourceLocation> SOURCE_LOCATION
```
  A Parser that returns the current location in the source.
  Because SourceLocation.getLine() and SourceLocation.getColumn() take amortized log(n) time, it's more efficient to avoid calling them until the entire source has been parsed successfully. In other words, avoid SOURCE_LOCATION.map(SourceLocation::getLine) or anything similar.
  SourceLocation#getIndex can be called any time.
  
  Since:
  
  3.1
- ALWAYS
```
private static final Parser ALWAYS
```
- NEVER
```
private static final Parser NEVER
```
- TRUE
```
static final Parser<java.lang.Boolean> TRUE
```
- FALSE
```
static final Parser<java.lang.Boolean> FALSE
```

Constructor Detail
- Parsers
```
private Parsers()
```

Method Detail

always
```
public static <T> Parser<T> always()
```
Parser that always succeeds.

never
```
public static <T> Parser<T> never()
```
Parser that always fails.

eof
```
static Parser<?> eof(java.lang.String message)
```
A Parser that succeeds only if EOF is met. Fails with message otherwise.

fail

public static <T> Parser<T> fail(java.lang.String message)

A Parser that always fails with message.

runnable

@Deprecated
public static Parser<?> runnable(java.lang.Runnable runnable)

Deprecated.

A Parser that always succeeds and invokes runnable.

tokens

static Parser<Token[]> tokens(Parser<? extends java.util.Collection<Token>> parser)

Converts a parser of a collection of Token to a parser of an array of Token.

nested
```
static <T> Parser<T> nested(Parser<Token[]> lexer,
                            Parser<? extends T> parser)
```
A Parser that takes as input the array of Token returned from lexer, and feeds the tokens as input into parser.
It fails if either lexer or parser fails.

Parameters:

lexer - the lexer object that returns an array of Tok objects.

parser - the token level parser object.

Returns:

the new Parser object.

constant
```
public static <T> Parser<T> constant(T v)
```
A Parser that always returns v regardless of input.

sequence

public static <T> Parser<T> sequence(Parser<?> p1,
                                     Parser<T> p2)

A Parser that runs 2 parser objects sequentially. p1 is executed, if it succeeds, p2 is executed.

sequence

public static <T> Parser<T> sequence(Parser<?> p1,
                                     Parser<?> p2,
                                     Parser<T> p3)

A Parser that runs 3 parser objects sequentially.

sequence

public static <T> Parser<T> sequence(Parser<?> p1,
                                     Parser<?> p2,
                                     Parser<?> p3,
                                     Parser<T> p4)

A Parser that runs 4 parser objects sequentially.

sequence

public static <T> Parser<T> sequence(Parser<?> p1,
                                     Parser<?> p2,
                                     Parser<?> p3,
                                     Parser<?> p4,
                                     Parser<T> p5)

A Parser that runs 5 parser objects sequentially.