org.antlr.runtime.tree
Class RewriteRuleElementStream

java.lang.Object
  extended by org.antlr.runtime.tree.RewriteRuleElementStream
Direct Known Subclasses:
RewriteRuleNodeStream, RewriteRuleSubtreeStream, RewriteRuleTokenStream

public abstract class RewriteRuleElementStream
extends java.lang.Object

A generic list of elements tracked in an alternative to be used in a -> rewrite rule. We need to subclass to fill in the next() method, which returns either an AST node wrapped around a token payload or an existing subtree. Once you start next()ing, do not try to add more elements. It will break the cursor tracking I believe.

See Also:
RewriteRuleSubtreeStream, TODO: add mechanism to detect/puke on modification after reading from stream

Field Summary
protected  TreeAdaptor adaptor
           
protected  int cursor
          Cursor 0..n-1.
protected  boolean dirty
          Once a node / subtree has been used in a stream, it must be dup'd from then on.
protected  java.lang.String elementDescription
          The element or stream description; usually has name of the token or rule reference that this list tracks.
protected  java.util.List elements
          The list of tokens or subtrees we are tracking
protected  java.lang.Object singleElement
          Track single elements w/o creating a list.
 
Constructor Summary
RewriteRuleElementStream(TreeAdaptor adaptor, java.lang.String elementDescription)
           
RewriteRuleElementStream(TreeAdaptor adaptor, java.lang.String elementDescription, java.util.List elements)
          Create a stream, but feed off an existing list
RewriteRuleElementStream(TreeAdaptor adaptor, java.lang.String elementDescription, java.lang.Object oneElement)
          Create a stream with one element
 
Method Summary
protected  java.lang.Object _next()
          do the work of getting the next element, making sure that it's a tree node or subtree.
 void add(java.lang.Object el)
           
protected abstract  java.lang.Object dup(java.lang.Object el)
          When constructing trees, sometimes we need to dup a token or AST subtree.
 java.lang.String getDescription()
           
 boolean hasNext()
           
 java.lang.Object nextTree()
          Return the next element in the stream.
 void reset()
          Reset the condition of this stream so that it appears we have not consumed any of its elements.
 int size()
           
protected  java.lang.Object toTree(java.lang.Object el)
          Ensure stream emits trees; tokens must be converted to AST nodes.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

cursor

protected int cursor
Cursor 0..n-1. If singleElement!=null, cursor is 0 until you next(), which bumps it to 1 meaning no more elements.


singleElement

protected java.lang.Object singleElement
Track single elements w/o creating a list. Upon 2nd add, alloc list


elements

protected java.util.List elements
The list of tokens or subtrees we are tracking


dirty

protected boolean dirty
Once a node / subtree has been used in a stream, it must be dup'd from then on. Streams are reset after subrules so that the streams can be reused in future subrules. So, reset must set a dirty bit. If dirty, then next() always returns a dup. I wanted to use "naughty bit" here, but couldn't think of a way to use "naughty".


elementDescription

protected java.lang.String elementDescription
The element or stream description; usually has name of the token or rule reference that this list tracks. Can include rulename too, but the exception would track that info.


adaptor

protected TreeAdaptor adaptor
Constructor Detail

RewriteRuleElementStream

public RewriteRuleElementStream(TreeAdaptor adaptor,
                                java.lang.String elementDescription)

RewriteRuleElementStream

public RewriteRuleElementStream(TreeAdaptor adaptor,
                                java.lang.String elementDescription,
                                java.lang.Object oneElement)
Create a stream with one element


RewriteRuleElementStream

public RewriteRuleElementStream(TreeAdaptor adaptor,
                                java.lang.String elementDescription,
                                java.util.List elements)
Create a stream, but feed off an existing list

Method Detail

reset

public void reset()
Reset the condition of this stream so that it appears we have not consumed any of its elements. Elements themselves are untouched. Once we reset the stream, any future use will need duplicates. Set the dirty bit.


add

public void add(java.lang.Object el)

nextTree

public java.lang.Object nextTree()
Return the next element in the stream. If out of elements, throw an exception unless size()==1. If size is 1, then return elements[0]. Return a duplicate node/subtree if stream is out of elements and size==1. If we've already used the element, dup (dirty bit set).


_next

protected java.lang.Object _next()
do the work of getting the next element, making sure that it's a tree node or subtree. Deal with the optimization of single- element list versus list of size > 1. Throw an exception if the stream is empty or we're out of elements and size>1. protected so you can override in a subclass if necessary.


dup

protected abstract java.lang.Object dup(java.lang.Object el)
When constructing trees, sometimes we need to dup a token or AST subtree. Dup'ing a token means just creating another AST node around it. For trees, you must call the adaptor.dupTree() unless the element is for a tree root; then it must be a node dup.


toTree

protected java.lang.Object toTree(java.lang.Object el)
Ensure stream emits trees; tokens must be converted to AST nodes. AST nodes can be passed through unmolested.


hasNext

public boolean hasNext()

size

public int size()

getDescription

public java.lang.String getDescription()


Copyright © 2013. All Rights Reserved.