Sequence

java.lang.Object
- com.oracle.truffle.regex.tregex.parser.ast.RegexASTNode
- - com.oracle.truffle.regex.tregex.parser.ast.Sequence

All Implemented Interfaces:

RegexASTVisitorIterable, JsonConvertible
```
public final class Sequence
extends RegexASTNode
implements RegexASTVisitorIterable
```
A Sequence is a concatenation of Terms.
Sequences are used as the alternatives in a Group. They are the only subtype of RegexASTNode which does not extend Term. In order to coerce a Sequence into a Term, wrap it in a Group (as its only alternative).
Corresponds to the goal symbol Alternative in the ECMAScript RegExp syntax.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`add(Term term)` Adds a `Term` to the end of the `Sequence`.
`Sequence`	`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)`
`Term`	`get(int i)`
`int`	`getEnclosedCaptureGroupsHigh()`
`int`	`getEnclosedCaptureGroupsLow()`
`Term`	`getFirstTerm()`
`Term`	`getLastTerm()`
`Group`	`getParent()` Gets the syntactic parent of this AST node.
`RegexASTSubtreeRootNode`	`getSubTreeParent()` Returns the subtree root node that this node is a part of.
`ArrayList<Term>`	`getTerms()` Returns the list of terms that constitute this `Sequence`.
`boolean`	`isEmpty()`
`boolean`	`isFirstInGroup()`
`boolean`	`isLastInGroup()`
`boolean`	`isLiteral()`
`boolean`	`isPenultimateInGroup()`
`boolean`	`isSingleCharClass()`
`void`	`removeLastTerm()` Removes the last `Term` from this `Sequence`.
`void`	`replace(int index, Term term)` Replaces the term at position `index` with the given `Term`.
`void`	`resetVisitorIterator()`
`void`	`setParent(RegexASTNode parent)` Sets the syntactic parent of this AST node.
`int`	`size()`
`JsonValue`	`toJson()`
`String`	`toString()`
`RegexASTNode`	`visitorGetNext(boolean reverse)`
`boolean`	`visitorHasNext()`

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, 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, 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 Sequence 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 RegexASTNode
    
    Parameters:
    
    ast - RegexAST the new nodes should belong to.
    
    Returns:
    
    A shallow or deep copy of this node.
  - getParent
```
public Group getParent()
```
    Description copied from class: RegexASTNode
    
    Gets the syntactic parent of this AST node.
    
    Overrides:
    
    getParent in class RegexASTNode
  - setParent
```
public void setParent(RegexASTNode parent)
```
    Description copied from class: RegexASTNode
    
    Sets the syntactic parent of this AST node.
    
    Overrides:
    
    setParent in class RegexASTNode
  - getTerms
```
public ArrayList<Term> getTerms()
```
    Returns the list of terms that constitute this Sequence.
    Note that elements should not be added or removed from this list. Use the methods Sequence.add(Term) and Sequence.removeLastTerm() instead.
  - isEmpty
```
public boolean isEmpty()
```
  - size
```
public int size()
```
  - getFirstTerm
```
public Term getFirstTerm()
```
  - get
```
public Term get(int i)
```
  - getLastTerm
```
public Term getLastTerm()
```
  - add
```
public void add(Term term)
```
    Adds a Term to the end of the Sequence.
    
    Parameters:
    
    term -
  - replace
```
public void replace(int index,
                    Term term)
```
    Replaces the term at position index with the given Term.
    
    Parameters:
    
    term -
  - removeLastTerm
```
public void removeLastTerm()
```
    Removes the last Term from this Sequence.
  - isFirstInGroup
```
public boolean isFirstInGroup()
```
  - isLastInGroup
```
public boolean isLastInGroup()
```
  - isPenultimateInGroup
```
public boolean isPenultimateInGroup()
```
  - isLiteral
```
public boolean isLiteral()
```
  - isSingleCharClass
```
public boolean isSingleCharClass()
```
  - getEnclosedCaptureGroupsLow
```
public int getEnclosedCaptureGroupsLow()
```
  - getEnclosedCaptureGroupsHigh
```
public int getEnclosedCaptureGroupsHigh()
```
  - getSubTreeParent
```
public RegexASTSubtreeRootNode getSubTreeParent()
```
    Description copied from class: RegexASTNode
    
    Returns the subtree root node that this node is a part of. If this node is nested inside several look-around assertion nodes, returns the innermost one that contains this node. Every AST node should have a subtree parent, but nodes implicitly generated by RegexAST.getNFAAnchoredInitialState(int) and RegexAST.getNFAUnAnchoredInitialState(int) technically don't belong to the AST, so they will return null.
    
    Specified by:
    
    getSubTreeParent in class RegexASTNode
  - visitorHasNext
```
public boolean visitorHasNext()
```
    Specified by:
    
    visitorHasNext in interface RegexASTVisitorIterable
  - resetVisitorIterator
```
public void resetVisitorIterator()
```
    Specified by:
    
    resetVisitorIterator in interface RegexASTVisitorIterable
  - visitorGetNext
```
public RegexASTNode visitorGetNext(boolean reverse)
```
    Specified by:
    
    visitorGetNext in interface RegexASTVisitorIterable
  - equalsSemantic
```
public boolean equalsSemantic(RegexASTNode obj)
```
    Specified by:
    
    equalsSemantic in class RegexASTNode
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - toJson
```
public JsonValue toJson()
```
    Specified by:
    
    toJson in interface JsonConvertible

Class Sequence

Method Summary

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

Methods inherited from class java.lang.Object

Method Detail

copy

getParent

setParent

getTerms

isEmpty

size

getFirstTerm

get

getLastTerm

add

replace

removeLastTerm

isFirstInGroup

isLastInGroup

isPenultimateInGroup

isLiteral

isSingleCharClass

getEnclosedCaptureGroupsLow

getEnclosedCaptureGroupsHigh

getSubTreeParent

visitorHasNext

resetVisitorIterator

visitorGetNext

equalsSemantic

toString

toJson