Regular

java.lang.Object
- org.stekikun.dolmen.syntax.Regular

Direct Known Subclasses:

Regular.Alternate, Regular.Binding, Regular.Characters, Regular.Eof, Regular.Epsilon, Regular.Repetition, Regular.Sequence
```
public abstract class Regular
extends Object
```
Instances of Regular represent concrete regular expressions. They are immutable objects, and have therefore value semantics.

Author:

Stéphane Lescuyer

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Regular.Alternate` Instances of regular expressions that represent a choice `a \| b` between two regular expressions.
`static class`	`Regular.Binding` Instances of regular expressions that represent expressions whose matchers will be bound to a specified name
`static class`	`Regular.Characters` Instances of regular expressions that match exactly one character amongst a set of possible characters.
`static class`	`Regular.Eof` The singleton class that stands for the regular expression matching the "end of input", or EOF, which only matches when the input string has been entirely consumed.
`static class`	`Regular.Epsilon` The singleton class that stands for the empty regular expression ε, which only matches the empty string.
`static interface`	`Regular.Folder<V>` An instance of `Regular.Folder` is a set of methods to apply to the various cases of a regular expression, depending on its form, as part of a (possibly) recursive traversal of the regular expression structure.
`static class`	`Regular.Gen` Generates random regular expressions based on a probability configuration and a random number generator
`static class`	`Regular.Kind` Enumeration which describes the different kinds of concrete implementations of `Regular`.
`static class`	`Regular.Repetition` Instances of regular expressions that represent the Kleene closure `r*` of some regular expression `r`, i.e. matching zero, one or more repetitions of `r`
`static class`	`Regular.Sequence` Instances of regular expressions that represent the concatenation `ab` of two regular expressions.

Field Summary

Fields
Modifier and Type	Field and Description
`static Regular.Eof`	`EOF` The regular expression matching the end-of-file/end-of-input
`static Regular.Epsilon`	`EPSILON` The empty regular expression ε
`boolean`	`hasBindings` Whether this regular expressions has any bound submatching group or not
`Regular.Kind`	`kind` Specifies what kind of regular expression `this` is
`boolean`	`nullable` Whether this regular expression matches the empty string.
`int`	`size` If `size` >= 0, all strings matching this regular expression have the specified size.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`static Regular.Binding`	`binding(Regular reg, Located<String> name)`
`static Regular`	`chars(CSet chars)`
`abstract <V> V`	`fold(Regular.Folder<V> folder)`
`static Regular.Gen`	`generator()`
`Regular.Kind`	`getKind()` Only there for the quick-assist based on `Hierarchy`.
`static Regular`	`or(Regular reg1, Regular... regs)`
`static Regular`	`or(Regular lhs, Regular rhs)`
`static Regular`	`plus(Regular reg)`
`static Regular`	`repeat(Regular reg, int occ)`
`static Regular`	`repeat(Regular reg, int min, int max)`
`static Regular`	`seq(Regular... regs)`
`static Regular`	`seq(Regular first, Regular second)`
`static Regular`	`star(Regular reg)`
`static Regular`	`string(String s)`
`abstract @NonNull String`	`toString()`

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

- Field Detail
  - kind
```
public final Regular.Kind kind
```
    Specifies what kind of regular expression this is
  - size
```
public final int size
```
    If size >= 0, all strings matching this regular expression have the specified size. If size is negative, then no size is guaranteed.
  - hasBindings
```
public final boolean hasBindings
```
    Whether this regular expressions has any bound submatching group or not
  - nullable
```
public final boolean nullable
```
    Whether this regular expression matches the empty string.
    Note that the end-of-file regular expression does not match the empty string, it matches a special character instead.
  - EPSILON
```
public static final Regular.Epsilon EPSILON
```
    The empty regular expression ε
  - EOF
```
public static final Regular.Eof EOF
```
    The regular expression matching the end-of-file/end-of-input
- Method Detail
  - getKind
```
public final Regular.Kind getKind()
```
    Only there for the quick-assist based on Hierarchy. You should probably use the field kind directly.
    
    Returns:
    
    kind
  - fold
```
public abstract <V> V fold(Regular.Folder<V> folder)
```
    Parameters:
    
    folder -
    
    Returns:
    
    the result of applying the provided Regular.Folder to the receiver
  - toString
```
public abstract @NonNull String toString()
```
    Overrides:
    
    toString in class Object
  - chars
```
public static Regular chars(CSet chars)
```
    Parameters:
    
    chars - must not contain CSet.EOF
    
    Returns:
    
    a regular expression which matches exactly one character in the character set chars
  - string
```
public static Regular string(String s)
```
    Parameters:
    
    s -
    
    Returns:
    
    a regular expression matching exactly the given string s
  - or
```
public static Regular or(Regular lhs,
                         Regular rhs)
```
    Parameters:
    
    lhs -
    
    rhs -
    
    Returns:
    
    the regular expression representing the alternative of lhs and rhs, in this order
  - or
```
public static Regular or(Regular reg1,
                         Regular... regs)
```
    Parameters:
    
    reg1 -
    
    regs -
    
    Returns:
    
    the regular expression (((reg1 || regs[0]) || regs[1]) ... || regs[n-1]
  - seq
```
public static Regular seq(Regular first,
                          Regular second)
```
    Parameters:
    
    first -
    
    second -
    
    Returns:
    
    the regular expression representing the concatenation of first and second, in this order
  - seq
```
public static Regular seq(Regular... regs)
```
    Parameters:
    
    regs -
    
    Returns:
    
    the concatenation of all regular expressions in regs, in order
  - star
```
public static Regular star(Regular reg)
```
    Parameters:
    
    reg -
    
    Returns:
    
    the regular expression representing any number of repetitions of reg
  - plus
```
public static Regular plus(Regular reg)
```
    Parameters:
    
    reg -
    
    Returns:
    
    the regular expression representing one or more repetitions of reg
  - repeat
```
public static Regular repeat(Regular reg,
                             int occ)
```
    Parameters:
    
    reg -
    
    occ -
    
    Returns:
    
    the regular expression representing exactly occ occurrences of reg
  - repeat
```
public static Regular repeat(Regular reg,
                             int min,
                             int max)
```
    Parameters:
    
    reg -
    
    min -
    
    max -
    
    Returns:
    
    the regular expression representing any number of occurrences of reg between min and max, inclusive
  - binding
```
public static Regular.Binding binding(Regular reg,
                                      Located<String> name)
```
    Parameters:
    
    reg -
    
    name -
    
    Returns:
    
    a regular expression with a binding to name
  - generator
```
public static Regular.Gen generator()
```
    Returns:
    
    a regular expression generator random generator based on a default configuration

Class Regular

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

kind

size

hasBindings

nullable

EPSILON

EOF

Method Detail

getKind

fold

toString

chars

string

or

or

seq

seq

star

plus

repeat

repeat

binding

generator