Class RewriteRuleElementStream

    • Field Summary

      Fields 
      Modifier and Type Field Description
      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<java.lang.Object> elements
      The list of tokens or subtrees we are tracking
      protected java.lang.Object singleElement
      Track single elements w/o creating a list.
    • Method Summary

      All Methods Instance Methods Abstract Methods Concrete Methods 
      Modifier and Type Method Description
      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<java.lang.Object> 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". TODO: unused?
      • 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.
    • 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<java.lang.Object> 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()