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.Group

All Implemented Interfaces:

IndexedState, RegexASTVisitorIterable, JsonConvertible
```
public final class Group
extends Term
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.

Field Summary
- Fields inherited from class com.oracle.truffle.regex.tregex.parser.ast.RegexASTNode
  FLAG_CHARACTER_CLASS_WAS_SINGLE_CHAR, FLAG_EMPTY_GUARD, FLAG_GROUP_EXPANDED_QUANTIFIER, FLAG_GROUP_LOOP, FLAG_HAS_LOOPS, FLAG_LOOK_AROUND_NEGATED

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.
`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`	`isCapturing()` Returns whether this group is a capturing group.
`boolean`	`isEmpty()`
`boolean`	`isExpandedQuantifier()` Indicates whether this `Group` was inserted into the AST as the result of expanding quantifier syntax (*, +, ?, {n,m}).
`boolean`	`isLiteral()`
`boolean`	`isLoop()` Returns whether or not this group loops.
`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`	`setExpandedQuantifier(boolean expandedQuantifier)` Marks this `Group` as being inserted into the AST as part of expanding quantifier syntax (*, +, ?, {n,m}).
`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.Term
equalsSemantic, getQuantifier, getSeqIndex, getSubTreeParent, hasQuantifier, quantifierToString, setQuantifier, setSeqIndex

Methods inherited from class com.oracle.truffle.regex.tregex.parser.ast.RegexASTNode
astNodeId, endsWithDollar, getId, getMaxPath, getMinPath, getParent, hasEmptyGuard, hasLoops, idInitialized, incMaxPath, incMaxPath, incMinPath, incMinPath, isDead, isFlagSet, isInLookAheadAssertion, isInLookBehindAssertion, isPrefix, markAsDead, setEmptyGuard, setEndsWithDollar, setEndsWithDollar, setFlag, setFlag, setHasLoops, setHasLoops, 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

- 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 Term
    
    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()
  - isExpandedQuantifier
```
public boolean isExpandedQuantifier()
```
    Indicates whether this Group was inserted into the AST as the result of expanding quantifier syntax (*, +, ?, {n,m}). E.g., if A is some group, then:
    - A* is expanded as (A|)*
    - A*? is expanded as (|A)*
    - A+ is expanded as A(A|)*
    - A+? is expanded as A(|A)*
    - A? is expanded as (A|)
    - A?? is expanded as (|A)
    - A{2,4} is expanded as AA(A|)(A|)
    - A{2,4}? is expanded as AA(|A)(|A)
    where (X|Y) is a group with alternatives X and Y and (X|Y)* is a looping group with alternatives X and Y. In the examples above, all of the occurrences of A in the expansions would be marked with this flag.
  - setExpandedQuantifier
```
public void setExpandedQuantifier(boolean expandedQuantifier)
```
    Marks this Group as being inserted into the AST as part of expanding quantifier syntax (*, +, ?, {n,m}).
    
    See Also:
    
    Group.isExpandedQuantifier()
  - 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()
```
  - 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)
```
  - 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 Term
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - toJson
```
public JsonValue toJson()
```
    Specified by:
    
    toJson in interface JsonConvertible

Class Group

Field Summary

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

Method Summary

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

Method Detail

copy

isLoop

setLoop

isExpandedQuantifier

setExpandedQuantifier

getGroupNumber

getBoundaryIndexStart

getBoundaryIndexEnd

groupNumberToBoundaryIndexStart

groupNumberToBoundaryIndexEnd

isCapturing

setGroupNumber

getEnclosedCaptureGroupsLow

setEnclosedCaptureGroupsLow

getEnclosedCaptureGroupsHigh

setEnclosedCaptureGroupsHigh

hasEnclosedCaptureGroups

getAlternatives

setAlternatives

size

isEmpty

add

insertFirst

addSequence

getLastAlternative

removeLastSequence

isLiteral

visitorHasNext

visitorGetNext

resetVisitorIterator

alternativesToString

loopToString

equalsSemantic

toString

toJson