Package proguard.classfile.attribute.signature.parsing

Class Combinators

java.lang.Object

proguard.classfile.attribute.signature.parsing.Combinators

public final class Combinators
extends java.lang.Object

Wrapper class containing parser combinators. Tools to chain together multiple parsers into more complex parsers.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static interface	Combinators.BiCombinator<A,B,R>
static interface	Combinators.PentaCombinator<A,B,C,D,E,R>
static interface	Combinators.QuaterCombinator<A,B,C,D,R>
static interface	Combinators.TerCombinator<A,B,C,R>

Constructor Summary

Constructors

Constructor	Description
Combinators()

Method Summary

Modifier and Type	Method	Description
static <A,B,R> Parser<R>	chain(Parser<A> aParser, Parser<B> bParser, Combinators.BiCombinator<A,B,R> combinator)	Take two parsers and return a new one, which will pass iff both parsers succeed when running one after the other.
static <A,B,C,R> Parser<R>	chain(Parser<A> aParser, Parser<B> bParser, Parser<C> cParser, Combinators.TerCombinator<A,B,C,R> combinator)	Same as chain(Parser, Parser, BiCombinator), just with 3 parsers.
static <A,B,C,D,R> Parser<R>	chain(Parser<A> aParser, Parser<B> bParser, Parser<C> cParser, Parser<D> dParser, Combinators.QuaterCombinator<A,B,C,D,R> combinator)	Same as chain(Parser, Parser, BiCombinator), just with 4 parsers.
static <A,B,C,D,E,R> Parser<R>	chain(Parser<A> aParser, Parser<B> bParser, Parser<C> cParser, Parser<D> dParser, Parser<E> eParser, Combinators.PentaCombinator<A,B,C,D,E,R> combinator)	Same as chain(Parser, Parser, BiCombinator), just with 5 parsers.
static <T> Parser<T>	oneOf(Parser<? extends T>... parsers)	Given a list of parsers of the same type, return a result of the first one that succeeds.
static <T> Parser<java.util.Optional<T>>	optional(Parser<T> parser)	Return a parser which succeeds even in cases when it can't parse anything.
static <T> Parser<java.util.List<T>>	repeat(Parser<T> parser)	Construct a new parser, that will try to run the given one repeatedly and return a list.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Combinators

public Combinators()

Method Detail

chain

public static <A,B,R> Parser<R> chain(Parser<A> aParser,
                                                  Parser<B> bParser,
                                                  Combinators.BiCombinator<A,B,R> combinator)

Take two parsers and return a new one, which will pass iff both parsers succeed when running one after the other.

Type Parameters:

A - Return type of the first parser.

B - Return type of the second parser.

R - The new return type.

Parameters:

aParser - The parser that should run first.

bParser - The second parser.

combinator - A function to combine the result of both parsers into one object.

Returns:

A new parser which succeeds only when both input parsers succeed.

chain

public static <A,B,C,R> Parser<R> chain(Parser<A> aParser,
                                                          Parser<B> bParser,
                                                          Parser<C> cParser,
                                                          Combinators.TerCombinator<A,B,C,R> combinator)

Same as chain(Parser, Parser, BiCombinator), just with 3 parsers.

chain

public static <A,B,C,D,R> Parser<R> chain(Parser<A> aParser,
                                                                  Parser<B> bParser,
                                                                  Parser<C> cParser,
                                                                  Parser<D> dParser,
                                                                  Combinators.QuaterCombinator<A,B,C,D,R> combinator)

Same as chain(Parser, Parser, BiCombinator), just with 4 parsers.

chain

public static <A,B,C,D,E,R> Parser<R> chain(Parser<A> aParser,
                                                                          Parser<B> bParser,
                                                                          Parser<C> cParser,
                                                                          Parser<D> dParser,
                                                                          Parser<E> eParser,
                                                                          Combinators.PentaCombinator<A,B,C,D,E,R> combinator)

Same as chain(Parser, Parser, BiCombinator), just with 5 parsers.

repeat

public static <T> Parser<java.util.List<T>> repeat(Parser<T> parser)

Construct a new parser, that will try to run the given one repeatedly and return a list.

Note: This parser always succeeds, because if it won't match anything, it will still return an empty list.

Type Parameters:

T - Return type of the input parser.

Parameters:

parser - The parser to repeatedly run.

Returns:

The new parser.

optional

public static <T> Parser<java.util.Optional<T>> optional(Parser<T> parser)

Return a parser which succeeds even in cases when it can't parse anything.

Type Parameters:

T - The return type of the parser.

Parameters:

parser - A parser to wrap with an optional check.

Returns:

A new parser that doesn't fail when no input is successfully parsed.

oneOf

@SafeVarargs
public static <T> Parser<T> oneOf(Parser<? extends T>... parsers)

Given a list of parsers of the same type, return a result of the first one that succeeds. Or null if none succeed.

Type Parameters:

T - The return type of all the parsers involved.

Parameters:

parsers - The input parsers to all try.

Returns:

A new parser that tries all the given parsers.