BaseParser (grappa 2.0.4-SNAPSHOT API)

java.lang.Object
- com.github.fge.grappa.parsers.BaseActions<V>
- - com.github.fge.grappa.parsers.BaseParser<V>

Type Parameters:
V - the type of the parser values

All Implemented Interfaces:

ContextAware<V>

Direct Known Subclasses:

ListeningParser
```
@ParametersAreNonnullByDefault
public abstract class BaseParser<V>
extends BaseActions<V>
```
Base class of all parboiled parsers. Defines the basic rule creation methods.

Field Summary

Fields
Modifier and Type	Field and Description
`protected static Rule`	`ANY` Matches any character except `Chars.EOI`.
`protected static Rule`	`EMPTY` Matches nothing and always succeeds.
`protected static Rule`	`EOI` End of input rule
`protected static Rule`	`NOTHING` Matches nothing and always fails.

Constructor Summary

Constructors
Constructor and Description

BaseParser()

Constructors
Constructor and Description
`BaseParser()`

Method Summary

Methods
Modifier and Type	Method and Description
`static <T> Action<T>`	`ACTION(boolean expression)` Explicitly marks the wrapped expression as an action expression.
`Rule`	`alpha()` ALPHA as defined by RFC 5234, appendix B, section 1: ASCII letters
`Rule`	`anyOf(char[] characters)` Match any character in the given `char` array
`Rule`	`anyOf(Characters characters)` Match any given character among a set of characters
`Rule`	`anyOf(String characters)` Match any of the characters in the given string
`Rule`	`asciiChars()` CHAR as defined by RFC 5234, appendix B, section 1: ASCII, except NUL
`Rule`	`bit()` BIT as defined by RFC 5234, appendix B, section 1: `0` or `1`
`Rule`	`ch(char c)` Match one given character
`Rule`	`charRange(char cLow, char cHigh)` Match an inclusive range of `char`s
`Rule`	`cr()` CR as defined by RFC 5234, appendix B, section 1 (`\r`)
`Rule`	`crlf()` CRLF as defined by RFC 5234, appendix B, section 1 (`\r\n`
`Rule`	`ctl()` CTL as defined by RFC 5234, appendix B, section 1: control characters
`Rule`	`digit()` DIGIT as defined by RFC 5234, appendix B, section 1 (0 to 9)
`Rule`	`dquote()` DQUOTE as defined by RFC 5234, appendix B, section 1 `"`
`Rule`	`empty()` Match an empty string
`Rule`	`eof()` Match only at the end of input
`Rule`	`firstOf(Object[] rules)` Match the first rule of a series of rules
`Rule`	`firstOf(Object rule, Object rule2, Object... moreRules)` Match the first rule of a series of rules
`protected Rule`	`fromCharArray(char[] array)` Used internally to convert the given char array to a parser rule.
`protected Rule`	`fromCharLiteral(char c)` Used internally to convert the given character literal to a parser rule.
`protected Rule`	`fromStringLiteral(String string)` Used internally to convert the given string literal to a parser rule.
`Rule`	`hexDigit()` Hexadecimal digits, case insensitive
`Rule`	`hexDigitLowerCase()` Hexadecimal digits, lowercase
`Rule`	`hexDigitUpperCase()` Hexadecimal digits, uppercase
`Rule`	`hTab()` HTAB as defined by RFC 5234, appendix B, section 1 (`\t`)
`Rule`	`ignoreCase(char... characters)` Match a sequence of characters as a string literal (case insensitive)
`Rule`	`ignoreCase(char c)` Match a given character in a case-insensitive manner
`Rule`	`ignoreCase(String string)` Match a string literal in a case insensitive manner
`JoinMatcherBootstrap<V,BaseParser<V>>`	`join(Object rule)` Kickstart a `join` rule
`JoinMatcherBootstrap<V,BaseParser<V>>`	`join(Object rule, Object rule2, Object... moreRules)` Kickstart a `join` rule
`Rule`	`lf()` LF as defined by RFC 5234, appendix B, section 1 (`\n`)
`Rule`	`noneOf(char[] characters)` Match all characters except the ones in the `char` array given as an argument
`Rule`	`noneOf(String characters)` Match any characters except the ones contained in the strings
`Rule`	`nTimes(int repetitions, Object rule)` Deprecated. use `repeat(Object)` instead
`Rule`	`octet()` OCTET as defined by RFC 5234, appendix B, section 1 (0x00 to 0xff)
`Rule`	`oneOrMore(Object rule)` Try and match a rule repeatedly, at least once
`Rule`	`oneOrMore(Object rule, Object rule2, Object... moreRules)` Try and repeatedly match a set of rules, at least once
`Rule`	`optional(Object rule)` Try and match a rule zero or one time
`Rule`	`optional(Object rule, Object rule2, Object... moreRules)` Try and match a given set of rules once
`Rule`	`regex(String regex)` Match the input text using a Java regular expression
`RepeatMatcherBuilder<V>`	`repeat(Object rule)` Kickstart a repeat rule
`RepeatMatcherBuilder<V>`	`repeat(Object rule, Object rule2, Object... moreRules)` Kickstart a repeat rule
`Rule`	`sequence(Object[] rules)` Match a given set of rules, exactly once
`Rule`	`sequence(Object rule, Object rule2, Object... moreRules)` Match a given set of rules, exactly once
`Rule`	`sp()` SP as defined by RFC 5234, appendix B, section 1 (one space, 0x20)
`Rule`	`string(char... characters)` Match a given set of characters as a string literal
`Rule`	`string(String string)` Match a string literal
`Rule`	`test(Object rule)` Test a rule, but do not consume any input (predicate)
`Rule`	`test(Object rule, Object rule2, Object... moreRules)` Test a set of rules, but do not consume any input
`Rule`	`testNot(Object rule)` Test, without consuming an input, that a rule does not match
`Rule`	`testNot(Object rule, Object rule2, Object... moreRules)` Test that a set of rules do not apply at this position
`Rule`	`toRule(Object obj)` Converts the given object to a rule.
`Rule[]`	`toRules(Object... objects)` Converts the given object array to an array of rules.
`Rule`	`trie(Collection<String> strings)` Match one string among many using a trie
`Rule`	`trie(String first, String second, String... others)` Match one string among many using a trie
`Rule`	`trieIgnoreCase(Collection<String> strings)` Match one string among many using a trie, case insensitive version
`Rule`	`trieIgnoreCase(String first, String second, String... others)` Match one string among many using a trie, case insensitive
`Rule`	`unicodeChar(int codePoint)` Match one Unicode character
`Rule`	`unicodeRange(int low, int high)` Match a Unicode character range
`Rule`	`vchar()` VCHAR as defined by RFC 5234, appendix B, section 1: ASCII "visible"
`Rule`	`wsp()` WSP as defined by RFC 5234, appendix B, section 1: space or tab
`Rule`	`zeroOrMore(Object rule)` Try and match a rule zero or more times
`Rule`	`zeroOrMore(Object rule, Object rule2, Object... moreRules)` Try and match a set of rules zero or more times

Methods inherited from class com.github.fge.grappa.parsers.BaseActions
currentChar, currentIndex, drop, drop, dup, getContext, hasError, inPredicate, match, matchedChar, matchEnd, matchLength, matchOrDefault, matchRange, matchStart, peek, peek, peekAs, peekAs, poke, poke, pop, pop, popAs, popAs, position, push, push, setContext, swap, swap

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

- Field Detail
  - EOI
```
protected static final Rule EOI
```
    End of input rule
    Please don't use this directly; use eof() instead.
  - ANY
```
protected static final Rule ANY
```
    Matches any character except Chars.EOI.
  - EMPTY
```
protected static final Rule EMPTY
```
    Matches nothing and always succeeds.
  - NOTHING
```
protected static final Rule NOTHING
```
    Matches nothing and always fails.
- Constructor Detail
  - BaseParser
```
public BaseParser()
```
- Method Detail
  - empty
```
@DontExtend
public Rule empty()
```
    Match an empty string
    
    Returns:
    a rule
  - eof
```
@DontExtend
public Rule eof()
```
    Match only at the end of input
    
    Returns:
    a rule
  - ch
```
@Cached
@DontLabel
public Rule ch(char c)
```
    Match one given character
    
    Parameters:
    c - the character to match
    
    Returns:
    a rule
  - ignoreCase
```
@Cached
@DontLabel
public Rule ignoreCase(char c)
```
    Match a given character in a case-insensitive manner
    
    Parameters:
    c - the character to match
    
    Returns:
    a rule
  - unicodeChar
```
@Cached
@DontLabel
public Rule unicodeChar(int codePoint)
```
    Match one Unicode character
    
    Parameters:
    codePoint - the code point
    
    Returns:
    a rule
  - unicodeRange
```
@Cached
@DontLabel
public Rule unicodeRange(int low,
                                 int high)
```
    Match a Unicode character range
    Note that this method will delegate to "regular" character matchers if part of, or all of, the specified range is into the basic multilingual plane.
    
    Parameters:
    low - the lower code point (inclusive)
    high - the upper code point (inclusive)
    
    Returns:
    a rule
  - charRange
```
@Cached
@DontLabel
public Rule charRange(char cLow,
                              char cHigh)
```
    Match an inclusive range of chars
    
    Parameters:
    cLow - the start char of the range (inclusively)
    cHigh - the end char of the range (inclusively)
    
    Returns:
    a rule
  - anyOf
```
@DontLabel
public Rule anyOf(String characters)
```
    Match any of the characters in the given string
    This method delegates to anyOf(Characters).
    
    Parameters:
    characters - the characters
    
    Returns:
    a rule
    See Also:
    anyOf(Characters)
  - anyOf
```
@DontLabel
public Rule anyOf(char[] characters)
```
    Match any character in the given char array
    This method delegates to anyOf(Characters).
    
    Parameters:
    characters - the characters
    
    Returns:
    a rule
    See Also:
    anyOf(Characters)
  - anyOf
```
@Cached
@DontLabel
public Rule anyOf(Characters characters)
```
    Match any given character among a set of characters
    Both anyOf(char[]) and anyOf(String) ultimately delegate to this method, which caches its resuls.
    
    Parameters:
    characters - the characters
    
    Returns:
    a new rule
  - noneOf
```
@DontLabel
public Rule noneOf(String characters)
```
    Match any characters except the ones contained in the strings
    
    Parameters:
    characters - the characters
    
    Returns:
    a rule
  - noneOf
```
@DontLabel
public Rule noneOf(char[] characters)
```
    Match all characters except the ones in the char array given as an argument
    
    Parameters:
    characters - the characters
    
    Returns:
    a new rule
  - string
```
@DontLabel
public Rule string(String string)
```
    Match a string literal
    
    Parameters:
    string - the string to match
    
    Returns:
    a rule
  - string
```
@Cached
@DontLabel
public Rule string(char... characters)
```
    Match a given set of characters as a string literal
    
    Parameters:
    characters - the characters of the string to match
    
    Returns:
    a rule
  - ignoreCase
```
@DontLabel
public Rule ignoreCase(String string)
```
    Match a string literal in a case insensitive manner
    
    Parameters:
    string - the string to match
    
    Returns:
    a rule
  - ignoreCase
```
@Cached
@DontLabel
public Rule ignoreCase(char... characters)
```
    Match a sequence of characters as a string literal (case insensitive)
    
    Parameters:
    characters - the characters of the string to match
    
    Returns:
    a rule
  - regex
```
@Cached
@DontLabel
public Rule regex(String regex)
```
    Match the input text using a Java regular expression
    A few important considerations:
    - the method used to match text is Matcher.lookingAt(); it means that the match will always be attempted at the current index in the input;
    - no flags are passed to Pattern.compile(String), therefore if you want case insensitive matches etc, you have to use the appropriate regex modifiers in the regex itself (for instance, (?i) for case insensitivity).
    Parameters:
    regex - the regex
    
    Returns:
    a rule
    See Also:
    Pattern, Matcher.lookingAt(), Matcher.end()
  - trie
```
@Cached
public Rule trie(Collection<String> strings)
```
    Match one string among many using a trie
    Duplicate elements will be silently eliminated.
    
    Note that order of elements does not matter, and that this rule will always trie (err, try) and match the longest possible sequence. That is, if you build a rule with inputs "do" and "double" in this order and the input text is "doubles", then "double" will be matched. However, if the input text is "doubling" then "do" is matched instead.
    
    Note also that the minimum length of strings in a trie is 2.
    
    Parameters:
    strings - the list of strings for this trie
    
    Returns:
    a rule
    See Also:
    TrieMatcher, TrieNode
  - trie
```
public Rule trie(String first,
        String second,
        String... others)
```
    Match one string among many using a trie
    This method delegates to trie(Collection).
    
    Parameters:
    first - the first string
    second - the second string
    others - other strings
    
    Returns:
    a rule
    See Also:
    TrieMatcher, TrieNode
  - trieIgnoreCase
```
@Cached
public Rule trieIgnoreCase(Collection<String> strings)
```
    Match one string among many using a trie, case insensitive version
    Duplicate elements will be silently eliminated.
    
    Note that order of elements does not matter, and that this rule will always trie (err, try) and match the longest possible sequence. That is, if you build a rule with inputs "do" and "double" in this order and the input text is "doubles", then "double" will be matched. However, if the input text is "doubling" then "do" is matched instead.
    
    Note also that the minimum length of strings in a trie is 2.
    
    Parameters:
    strings - the list of strings for this trie
    
    Returns:
    a rule
    See Also:
    CaseInsensitiveTrieMatcher
  - trieIgnoreCase
```
public Rule trieIgnoreCase(String first,
                  String second,
                  String... others)
```
    Match one string among many using a trie, case insensitive
    This method delegates to trieIgnoreCase(Collection).
    
    Parameters:
    first - the first string
    second - the second string
    others - other strings
    
    Returns:
    a rule
    See Also:
    CaseInsensitiveTrieMatcher
  - firstOf
```
@DontLabel
public Rule firstOf(Object rule,
                     Object rule2,
                     Object... moreRules)
```
    Match the first rule of a series of rules
    When one rule matches, all others are ignored.
    
    Note: if you are considering matching one string among many, consider using trie(Collection)/trie(String, String, String...) instead.
    
    Parameters:
    rule - the first subrule
    rule2 - the second subrule
    moreRules - the other subrules
    
    Returns:
    a rule
  - firstOf
```
@Cached
@DontLabel
public Rule firstOf(Object[] rules)
```
    Match the first rule of a series of rules
    When one rule matches, all others are ignored.
    
    Parameters:
    rules - the subrules
    
    Returns:
    a rule
  - oneOrMore
```
@DontLabel
public Rule oneOrMore(Object rule)
```
    Try and match a rule repeatedly, at least once
    This is in fact an alias for repeat(rule).min(1).
    
    Parameters:
    rule - the subrule
    
    Returns:
    a rule
    See Also:
    repeat(Object)
  - oneOrMore
```
@DontLabel
public Rule oneOrMore(Object rule,
                       Object rule2,
                       Object... moreRules)
```
    Try and repeatedly match a set of rules, at least once
    This is in fact an alias for repeat(rule, rule2, ...).min(1).
    
    Parameters:
    rule - the first subrule
    rule2 - the second subrule
    moreRules - the other subrules
    
    Returns:
    a rule
    See Also:
    repeat(Object, Object, Object...)
  - optional
```
@Cached
@DontLabel
public Rule optional(Object rule)
```
    Try and match a rule zero or one time
    This rule therefore always succeeds.
    
    Parameters:
    rule - the subrule
    
    Returns:
    a rule
  - optional
```
@DontLabel
public Rule optional(Object rule,
                      Object rule2,
                      Object... moreRules)
```
    Try and match a given set of rules once
    This rule will therefore never fail.
    
    Parameters:
    rule - the first subrule
    rule2 - the second subrule
    moreRules - the other subrules
    
    Returns:
    a rule
  - sequence
```
@DontLabel
public Rule sequence(Object rule,
                      Object rule2,
                      Object... moreRules)
```
    Match a given set of rules, exactly once
    
    Parameters:
    rule - the first subrule
    rule2 - the second subrule
    moreRules - the other subrules
    
    Returns:
    a rule
  - sequence
```
@Cached
@DontLabel
public Rule sequence(Object[] rules)
```
    Match a given set of rules, exactly once
    
    Parameters:
    rules - the rules
    
    Returns:
    a rule
  - join
```
@DontLabel
public final JoinMatcherBootstrap<V,BaseParser<V>> join(Object rule)
```
    Kickstart a join rule
    Usages:
```
     return join(rule()).using(otherRule()).times(n);
     return join(rule()).using(otherRule()).min(n);
 
```
    etc. See JoinMatcherBuilder for more possible constructs.
    Parameters:
    rule - the joined rule (must not match an empty sequence!)
    
    Returns:
    a JoinMatcherBootstrap
    See Also:
    JoinMatcherBootstrap.using(Object)
  - join
```
@DontLabel
public final JoinMatcherBootstrap<V,BaseParser<V>> join(Object rule,
                                                   Object rule2,
                                                   Object... moreRules)
```
    Kickstart a join rule
    Like join(Object), except that several rules are accepted as arguments.
    
    Parameters:
    rule - first rule
    rule2 - second rule
    moreRules - other rules
    
    Returns:
    a JoinMatcherBootstrap
    See Also:
    sequence(Object, Object, Object...)
  - repeat
```
@DontLabel
public final RepeatMatcherBuilder<V> repeat(Object rule)
```
    Kickstart a repeat rule
    Usages:
```
     return repeat("Yes we can!").times(3);
     return repeat(someRule).min(2);
     // etc
 
```
    Parameters:
    rule - the rule to be repeated
    
    Returns:
    a builder
  - repeat
```
@DontLabel
public final RepeatMatcherBuilder<V> repeat(Object rule,
                                       Object rule2,
                                       Object... moreRules)
```
    Kickstart a repeat rule
    Like repeat(Object), except several rules are accepted as arguments.
    
    Parameters:
    rule - first rule
    rule2 - second rule
    moreRules - other rules
    
    Returns:
    a rule
    See Also:
    sequence(Object, Object, Object...)
  - test
```
@Cached
@DontLabel
public Rule test(Object rule)
```
    Test a rule, but do not consume any input (predicate)
    Its success conditions are the same as the rule. Note that this rule will never consume any input, nor will it create a parse tree node.
    
    Note that the embedded rule can be arbitrarily complex, and this includes potential Actions which can act on the stack for instance; these will be executed here, unless you have chosen to annotate your rule, or parser class, with SkipActionsInPredicates.
    
    Parameters:
    rule - the subrule
    
    Returns:
    a new rule
  - test
```
@DontLabel
public Rule test(Object rule,
                  Object rule2,
                  Object... moreRules)
```
    Test a set of rules, but do not consume any input
    
    Parameters:
    rule - the first subrule
    rule2 - the second subrule
    moreRules - the other subrules
    
    Returns:
    a new rule
    See Also:
    test(Object)
  - testNot
```
@Cached
@DontLabel
public Rule testNot(Object rule)
```
    Test, without consuming an input, that a rule does not match
    The same warnings given in the description of test(Object) apply here.
    
    Parameters:
    rule - the subrule
    
    Returns:
    a rule
  - testNot
```
@DontLabel
public Rule testNot(Object rule,
                     Object rule2,
                     Object... moreRules)
```
    Test that a set of rules do not apply at this position
    
    Parameters:
    rule - the first subrule
    rule2 - the second subrule
    moreRules - the other subrules
    
    Returns:
    a new rule
    See Also:
    test(Object), testNot(Object)
  - zeroOrMore
```
@DontLabel
public Rule zeroOrMore(Object rule)
```
    Try and match a rule zero or more times
    This is an alias for repeat(rule).min(0).
    
    Parameters:
    rule - the subrule
    
    Returns:
    a rule
    See Also:
    repeat(Object)
  - zeroOrMore
```
@DontLabel
public Rule zeroOrMore(Object rule,
                        Object rule2,
                        Object... moreRules)
```
    Try and match a set of rules zero or more times
    This is an alias for repeat(rule, rule2, ...).min(0).
    
    Parameters:
    rule - the first subrule
    rule2 - the second subrule
    moreRules - the other subrules
    
    Returns:
    a rule
  - nTimes
```
@Cached
@DontLabel
@Deprecated
public Rule nTimes(int repetitions,
                                      Object rule)
```
    Deprecated. use repeat(Object) instead
    
    Match a rule a fixed number of times
    
    Parameters:
    repetitions - The number of repetitions to match. Must be >= 0.
    rule - the sub rule to match repeatedly.
    
    Returns:
    a rule
  - alpha
```
public Rule alpha()
```
    ALPHA as defined by RFC 5234, appendix B, section 1: ASCII letters
    Therefore a-z, A-Z.
    
    Returns:
    a rule
  - bit
```
public Rule bit()
```
    BIT as defined by RFC 5234, appendix B, section 1: 0 or 1
    
    Returns:
    a rule
  - asciiChars
```
public Rule asciiChars()
```
    CHAR as defined by RFC 5234, appendix B, section 1: ASCII, except NUL
    That is, 0x01 to 0x7f.
    
    Returns:
    a rule
  - cr
```
public Rule cr()
```
    CR as defined by RFC 5234, appendix B, section 1 (\r)
    
    Returns:
    a rule
  - crlf
```
public Rule crlf()
```
    CRLF as defined by RFC 5234, appendix B, section 1 (\r\n
    
    Returns:
    a rule
  - ctl
```
public Rule ctl()
```
    CTL as defined by RFC 5234, appendix B, section 1: control characters
    0x00-0x1f, plus 0x7f.
    
    Returns:
    a rule
  - digit
```
public Rule digit()
```
    DIGIT as defined by RFC 5234, appendix B, section 1 (0 to 9)
    
    Returns:
    a rule
  - dquote
```
public Rule dquote()
```
    DQUOTE as defined by RFC 5234, appendix B, section 1 "
    
    Returns:
    a rule
  - hexDigit
```
public Rule hexDigit()
```
    Hexadecimal digits, case insensitive
    Note: RFC 5234 only defines HEXDIG for uppercase letters (A to F). Use hexDigitUpperCase() for this definition. Use hexDigitLowerCase() for lowercase letters only.
    
    Returns:
    a rule
  - hexDigitUpperCase
```
public Rule hexDigitUpperCase()
```
    Hexadecimal digits, uppercase
    
    Returns:
    a rule
    See Also:
    hexDigit()
  - hexDigitLowerCase
```
public Rule hexDigitLowerCase()
```
    Hexadecimal digits, lowercase
    
    Returns:
    a rule
    See Also:
    hexDigit()
  - hTab
```
public Rule hTab()
```
    HTAB as defined by RFC 5234, appendix B, section 1 (\t)
    
    Returns:
    a rule
  - lf
```
public Rule lf()
```
    LF as defined by RFC 5234, appendix B, section 1 (\n)
    
    Returns:
    a rule
  - octet
```
public Rule octet()
```
    OCTET as defined by RFC 5234, appendix B, section 1 (0x00 to 0xff)
    
    Returns:
    a rule
  - sp
```
public Rule sp()
```
    SP as defined by RFC 5234, appendix B, section 1 (one space, 0x20)
    
    Returns:
    a rule
  - vchar
```
public Rule vchar()
```
    VCHAR as defined by RFC 5234, appendix B, section 1: ASCII "visible"
    Letters, @, etc etc. Note that this excludes whitespace characters!
    
    Returns:
    a rule
  - wsp
```
public Rule wsp()
```
    WSP as defined by RFC 5234, appendix B, section 1: space or tab
    
    Returns:
    a rule
  - ACTION
```
public static <T> Action<T> ACTION(boolean expression)
```
    Explicitly marks the wrapped expression as an action expression. parboiled transforms the wrapped expression into an Action instance during parser construction.
    
    Parameters:
    expression - the expression to turn into an Action
    
    Returns:
    the Action wrapping the given expression
  - fromCharLiteral
```
@DontExtend
protected Rule fromCharLiteral(char c)
```
    Used internally to convert the given character literal to a parser rule. You can override this method, e.g. for specifying a Sequence that automatically matches all trailing whitespace after the character.
    
    Parameters:
    c - the character
    
    Returns:
    the rule
  - fromStringLiteral
```
@DontExtend
protected Rule fromStringLiteral(String string)
```
    Used internally to convert the given string literal to a parser rule. You can override this method, e.g. for specifying a Sequence that automatically matches all trailing whitespace after the string.
    
    Parameters:
    string - the string
    
    Returns:
    the rule
  - fromCharArray
```
@DontExtend
protected Rule fromCharArray(char[] array)
```
    Used internally to convert the given char array to a parser rule. You can override this method, e.g. for specifying a Sequence that automatically matches all trailing whitespace after the characters.
    
    Parameters:
    array - the char array
    
    Returns:
    the rule
  - toRules
```
@DontExtend
public Rule[] toRules(Object... objects)
```
    Converts the given object array to an array of rules.
    
    Parameters:
    objects - the objects to convert
    
    Returns:
    the rules corresponding to the given objects
  - toRule
```
@DontExtend
public Rule toRule(Object obj)
```
    Converts the given object to a rule. This method can be overriden to enable the use of custom objects directly in rule specifications.
    
    Parameters:
    obj - the object to convert
    
    Returns:
    the rule corresponding to the given object

Class BaseParser<V>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class com.github.fge.grappa.parsers.BaseActions

Methods inherited from class java.lang.Object

Field Detail

EOI

ANY

EMPTY

NOTHING

Constructor Detail

BaseParser

Method Detail

empty

eof

ch

ignoreCase

unicodeChar

unicodeRange

charRange

anyOf

anyOf

anyOf

noneOf

noneOf

string

string

ignoreCase

ignoreCase

regex

trie

trie

trieIgnoreCase

trieIgnoreCase

firstOf

firstOf

oneOrMore

oneOrMore

optional

optional

sequence

sequence

join

join

repeat

repeat

test

test

testNot

testNot

zeroOrMore

zeroOrMore

nTimes

alpha

bit

asciiChars

cr

crlf

ctl

digit

dquote

hexDigit

hexDigitUpperCase

hexDigitLowerCase

hTab

lf

octet

sp

vchar

wsp

ACTION

fromCharLiteral

fromStringLiteral

fromCharArray

toRules

toRule