Group

java.lang.Object
- com.oracle.truffle.regex.tregex.parser.ast.RegexASTNode
- - com.oracle.truffle.regex.tregex.parser.ast.Term
  - - com.oracle.truffle.regex.tregex.parser.ast.QuantifiableTerm
    - - com.oracle.truffle.regex.tregex.parser.ast.Group

All Implemented Interfaces:

AbstractState<Term,ASTTransition>, RegexASTVisitorIterable, JsonConvertible
```
public final class Group
extends QuantifiableTerm
implements RegexASTVisitorIterable
```
Groups are the top-most elements of regular expression ASTs.
A Group is composed of several alternatives, each of which is a Sequence of other Terms. A Group can be wrapped in parentheses and used anywhere a Term is expected. Therefore, Group extends Term.
Corresponds to the goal symbol Disjunction and the right-hand sides ( Disjunction ) and ( ? : Disjunction ) of the goal symbol Atom in the ECMAScript RegExp syntax.
On top of managing alternation and capturing, the Group AST nodes are also the primitives used to represent loops (quantifiers * and +). A Group can be marked as looping, in which case successfully matching one of its non-empty alternatives should be followed by attempting to match the Group itself again.
The collections of alternatives that make up a Group is ordered and the order indicates the priority of the alternatives: if matching with an earlier alternative is possible, that match result is preferred to those from later alternatives.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`add(Sequence sequence)` Adds a new alternative to this group.
`Sequence`	`addSequence(RegexAST ast)` Creates a new empty alternatives and adds it to the end of the list of alternatives.
`String`	`alternativesToString()`
`Group`	`copy(RegexAST ast, boolean recursive)` Copy this node, in one of the following ways: if `recursive` is `true`, recursively copy this subtree.
`boolean`	`equalsSemantic(RegexASTNode obj, boolean ignoreQuantifier)`
`ArrayList<Sequence>`	`getAlternatives()` Returns the list of alternatives that make up this `Group`.
`int`	`getBoundaryIndexEnd()` Returns the index corresponding to this capture group's END in a result array returned by a capture-group aware DFA.
`int`	`getBoundaryIndexStart()` Returns the index corresponding to this capture group's BEGIN in a result array returned by a capture-group aware DFA.
`int`	`getEnclosedCaptureGroupsHigh()` Gets the (exclusive) upper bound of the range of capture groups contained within this group.
`int`	`getEnclosedCaptureGroupsLow()` Gets the (inclusive) lower bound of the range of capture groups contained within this group.
`Sequence`	`getFirstAlternative()`
`int`	`getGroupNumber()` Returns the number of this capturing group.
`Sequence`	`getLastAlternative()`
`static int`	`groupNumberToBoundaryIndexEnd(int groupNumber)` Returns the index corresponding to a capture group's END in a result array returned by a capture-group aware DFA.
`static int`	`groupNumberToBoundaryIndexStart(int groupNumber)` Returns the index corresponding to a capture group's BEGIN in a result array returned by a capture-group aware DFA.
`boolean`	`hasEnclosedCaptureGroups()`
`void`	`insertFirst(Sequence sequence)` Inserts a new alternative to this group.
`boolean`	`isAlwaysZeroWidth()` Returns `true` iff all alternatives of this group match only the empty string.
`boolean`	`isCapturing()` Returns whether this group is a capturing group.
`boolean`	`isEmpty()`
`boolean`	`isLiteral()`
`boolean`	`isLoop()` Returns whether or not this group loops.
`boolean`	`isUnrollingCandidate()` Returns `true` iff the parser should try to unroll this term's quantifier.
`String`	`loopToString()`
`void`	`removeLastSequence()`
`void`	`resetVisitorIterator()`
`void`	`setAlternatives(ArrayList<Sequence> alternatives)`
`void`	`setEnclosedCaptureGroupsHigh(int enclosedCaptureGroupsHigh)` Sets the (exclusive) upper bound of the range of capture groups contained within this group.
`void`	`setEnclosedCaptureGroupsLow(int enclosedCaptureGroupsLow)` Sets the (inclusive) lower bound of the range of capture groups contained within this group.
`void`	`setGroupNumber(int groupNumber)` Marks this `Group` as capturing and sets its group number.
`void`	`setLoop(boolean loop)` Sets whether or this group should loop.
`int`	`size()`
`JsonValue`	`toJson()`
`String`	`toString()`
`RegexASTNode`	`visitorGetNext(boolean reverse)`
`boolean`	`visitorHasNext()`

Methods inherited from class com.oracle.truffle.regex.tregex.parser.ast.QuantifiableTerm
equalsSemantic, getQuantifier, getSubTreeParent, hasNotUnrolledQuantifier, hasQuantifier, quantifierToString, setQuantifier

Methods inherited from class com.oracle.truffle.regex.tregex.parser.ast.Term
getSeqIndex, setSeqIndex

Methods inherited from class com.oracle.truffle.regex.tregex.parser.ast.RegexASTNode
asBackReference, asCharacterClass, asGroup, asLookAheadAssertion, asLookAroundAssertion, asLookBehindAssertion, asMatchFound, asPositionAssertion, asQuantifiableTerm, asSequence, astNodeId, endsWithDollar, getFlags, getId, getMaxPath, getMinPath, getParent, hasBackReferences, hasCaptureGroups, hasCaret, hasDollar, hasEmptyGuard, hasLookAheads, hasLookBehinds, hasLoops, hasQuantifiers, idInitialized, incMaxPath, incMaxPath, incMinPath, incMinPath, isBackReference, isCaret, isCharacterClass, isDead, isDollar, isExpandedQuantifier, isFlagSet, isGroup, isInLookAheadAssertion, isInLookBehindAssertion, isLookAheadAssertion, isLookAroundAssertion, isLookBehindAssertion, isMatchFound, isPositionAssertion, isPrefix, isQuantifiableTerm, isRoot, isSequence, isSubtreeRoot, markAsDead, setDead, setEmptyGuard, setEndsWithDollar, setEndsWithDollar, setExpandedQuantifier, setFlag, setFlag, setFlags, setHasBackReferences, setHasCaptureGroups, setHasCaret, setHasCaret, setHasDollar, setHasDollar, setHasLookAheads, setHasLookBehinds, setHasLoops, setHasLoops, setHasQuantifiers, setId, setMaxPath, setMinPath, setParent, setPrefix, setStartsWithCaret, setStartsWithCaret, startsWithCaret, toJson, toStringWithID

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

Methods inherited from interface com.oracle.truffle.regex.tregex.automaton.AbstractState
getId

- Method Detail
  - copy
```
public Group copy(RegexAST ast,
                  boolean recursive)
```
    Description copied from class: RegexASTNode
    Copy this node, in one of the following ways:
    - if recursive is true, recursively copy this subtree. This method should be used instead of CopyVisitor if the copying process is required to be thread-safe.
    - else, copy this node only, without any child nodes.
    In both cases, the ID and minPath of the copied nodes is left unset.
    Specified by:
    
    copy in class QuantifiableTerm
    
    Parameters:
    
    ast - RegexAST the new nodes should belong to.
    
    Returns:
    
    A shallow or deep copy of this node.
  - isLoop
```
public boolean isLoop()
```
    Returns whether or not this group loops. A looping group differs from a non-looping one in that when you match one of the group's non-empty alternatives, instead of continuing to the next node after the group, the same group is attempted again.
  - setLoop
```
public void setLoop(boolean loop)
```
    Sets whether or this group should loop. If the group is set to be looping, this updates the 'next' and 'prev' pointers on the non-empty alternatives to point to the group itself.
    
    Parameters:
    
    loop - true if this group should loop
    
    See Also:
    
    Group.isLoop()
  - getGroupNumber
```
public int getGroupNumber()
```
    Returns the number of this capturing group. If this group is not a capturing group, returns -1.
  - getBoundaryIndexStart
```
public int getBoundaryIndexStart()
```
    Returns the index corresponding to this capture group's BEGIN in a result array returned by a capture-group aware DFA.
  - getBoundaryIndexEnd
```
public int getBoundaryIndexEnd()
```
    Returns the index corresponding to this capture group's END in a result array returned by a capture-group aware DFA.
  - groupNumberToBoundaryIndexStart
```
public static int groupNumberToBoundaryIndexStart(int groupNumber)
```
    Returns the index corresponding to a capture group's BEGIN in a result array returned by a capture-group aware DFA.
  - groupNumberToBoundaryIndexEnd
```
public static int groupNumberToBoundaryIndexEnd(int groupNumber)
```
    Returns the index corresponding to a capture group's END in a result array returned by a capture-group aware DFA.
  - isCapturing
```
public boolean isCapturing()
```
    Returns whether this group is a capturing group.
    This is the case when this Group was built using the Group.Group(int) constructor or if Group.setGroupNumber(int) was called.
  - setGroupNumber
```
public void setGroupNumber(int groupNumber)
```
    Marks this Group as capturing and sets its group number.
    
    Parameters:
    
    groupNumber -
  - getEnclosedCaptureGroupsLow
```
public int getEnclosedCaptureGroupsLow()
```
    Gets the (inclusive) lower bound of the range of capture groups contained within this group.
  - setEnclosedCaptureGroupsLow
```
public void setEnclosedCaptureGroupsLow(int enclosedCaptureGroupsLow)
```
    Sets the (inclusive) lower bound of the range of capture groups contained within this group.
  - getEnclosedCaptureGroupsHigh
```
public int getEnclosedCaptureGroupsHigh()
```
    Gets the (exclusive) upper bound of the range of capture groups contained within this group.
  - setEnclosedCaptureGroupsHigh
```
public void setEnclosedCaptureGroupsHigh(int enclosedCaptureGroupsHigh)
```
    Sets the (exclusive) upper bound of the range of capture groups contained within this group.
  - hasEnclosedCaptureGroups
```
public boolean hasEnclosedCaptureGroups()
```
  - isAlwaysZeroWidth
```
public boolean isAlwaysZeroWidth()
```
    Returns true iff all alternatives of this group match only the empty string.
  - isUnrollingCandidate
```
public boolean isUnrollingCandidate()
```
    Description copied from class: QuantifiableTerm
    
    Returns true iff the parser should try to unroll this term's quantifier.
    
    Specified by:
    
    isUnrollingCandidate in class QuantifiableTerm
  - getAlternatives
```
public ArrayList<Sequence> getAlternatives()
```
    Returns the list of alternatives that make up this Group.
    Elements should not be added or removed from this list. Use the Group.add(Sequence), Group.insertFirst(Sequence) and Group.addSequence(RegexAST) methods instead.
  - setAlternatives
```
public void setAlternatives(ArrayList<Sequence> alternatives)
```
  - getFirstAlternative
```
public Sequence getFirstAlternative()
```
  - size
```
public int size()
```
  - isEmpty
```
public boolean isEmpty()
```
  - add
```
public void add(Sequence sequence)
```
    Adds a new alternative to this group. The new alternative will be appended to the end, meaning it will have the lowest priority among all the alternatives.
    
    Parameters:
    
    sequence -
  - insertFirst
```
public void insertFirst(Sequence sequence)
```
    Inserts a new alternative to this group. The new alternative will be inserted at the beginning, meaning it will have the highest priority among all the alternatives.
    
    Parameters:
    
    sequence -
  - addSequence
```
public Sequence addSequence(RegexAST ast)
```
    Creates a new empty alternatives and adds it to the end of the list of alternatives.
    
    Parameters:
    
    ast - The AST that the new alternative should belong to
    
    Returns:
    
    The newly created alternative
  - getLastAlternative
```
public Sequence getLastAlternative()
```
  - removeLastSequence
```
public void removeLastSequence()
```
  - isLiteral
```
public boolean isLiteral()
```
  - visitorHasNext
```
public boolean visitorHasNext()
```
    Specified by:
    
    visitorHasNext in interface RegexASTVisitorIterable
  - visitorGetNext
```
public RegexASTNode visitorGetNext(boolean reverse)
```
    Specified by:
    
    visitorGetNext in interface RegexASTVisitorIterable
  - resetVisitorIterator
```
public void resetVisitorIterator()
```
    Specified by:
    
    resetVisitorIterator in interface RegexASTVisitorIterable
  - alternativesToString
```
public String alternativesToString()
```
  - loopToString
```
public String loopToString()
```
  - equalsSemantic
```
public boolean equalsSemantic(RegexASTNode obj,
                              boolean ignoreQuantifier)
```
    Specified by:
    
    equalsSemantic in class QuantifiableTerm
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - toJson
```
public JsonValue toJson()
```
    Specified by:
    
    toJson in interface JsonConvertible

Class Group

Method Summary

Methods inherited from class com.oracle.truffle.regex.tregex.parser.ast.QuantifiableTerm

Methods inherited from class com.oracle.truffle.regex.tregex.parser.ast.Term

Methods inherited from class com.oracle.truffle.regex.tregex.parser.ast.RegexASTNode

Methods inherited from class java.lang.Object

Methods inherited from interface com.oracle.truffle.regex.tregex.automaton.AbstractState

Method Detail

copy

isLoop

setLoop

getGroupNumber

getBoundaryIndexStart

getBoundaryIndexEnd

groupNumberToBoundaryIndexStart

groupNumberToBoundaryIndexEnd

isCapturing

setGroupNumber

getEnclosedCaptureGroupsLow

setEnclosedCaptureGroupsLow

getEnclosedCaptureGroupsHigh

setEnclosedCaptureGroupsHigh

hasEnclosedCaptureGroups

isAlwaysZeroWidth

isUnrollingCandidate

getAlternatives

setAlternatives

getFirstAlternative

size

isEmpty

add

insertFirst

addSequence

getLastAlternative

removeLastSequence

isLiteral

visitorHasNext

visitorGetNext

resetVisitorIterator

alternativesToString

loopToString

equalsSemantic

toString

toJson