code: /*
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements. See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership. The ASF licenses this file
   * to you under the Apache License, Version 2.0 (the  "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /*
   * $Id$
   */
  package org.apache.xml.dtm;
  
  /**
  
   * <code>DTMIterators</code> are used to step through a (possibly
   * filtered) set of nodes.  Their API is modeled largely after the DOM
   * NodeIterator.
   * 
   * <p>A DTMIterator is a somewhat unusual type of iterator, in that it 
   * can serve both single node iteration and random access.</p>
   * 
   * <p>The DTMIterator's traversal semantics, i.e. how it walks the tree,
   * are specified when it is created, possibly and probably by an XPath
   * <a href="http://www.w3.org/TR/xpath#NT-LocationPath>LocationPath</a> or 
   * a <a href="http://www.w3.org/TR/xpath#NT-UnionExpr">UnionExpr</a>.</p>
   * 
   * <p>A DTMIterator is meant to be created once as a master static object, and 
   * then cloned many times for runtime use.  Or the master object itself may 
   * be used for simpler use cases.</p>
   *
   * <p>At this time, we do not expect DTMIterator to emulate
   * NodeIterator's "maintain relative position" semantics under
   * document mutation.  It's likely to respond more like the
   * TreeWalker's "current node" semantics. However, since the base DTM
   * is immutable, this issue currently makes no practical
   * difference.</p>
   *
   * <p>State: In progress!!</p> */
  public interface DTMIterator
  {
  
    // Constants returned by acceptNode, borrowed from the DOM Traversal chapter
    // %REVIEW% Should we explicitly initialize them from, eg,
    // org.w3c.dom.traversal.NodeFilter.FILTER_ACCEPT?
  
    /**
     * Accept the node.
     */
    public static final short FILTER_ACCEPT = 1;
  
    /**
     * Reject the node. Same behavior as FILTER_SKIP. (In the DOM these
     * differ when applied to a TreeWalker but have the same result when
     * applied to a NodeIterator).
     */
    public static final short FILTER_REJECT = 2;
  
    /**
     * Skip this single node. 
     */
    public static final short FILTER_SKIP = 3;
      
    /**
     * Get an instance of a DTM that "owns" a node handle.  Since a node 
     * iterator may be passed without a DTMManager, this allows the 
     * caller to easily get the DTM using just the iterator.
     *
     * @param nodeHandle the nodeHandle.
     *
     * @return a non-null DTM reference.
     */
    public DTM getDTM(int nodeHandle);
    
    /**
     * Get an instance of the DTMManager.  Since a node 
     * iterator may be passed without a DTMManager, this allows the 
     * caller to easily get the DTMManager using just the iterator.
     *
     * @return a non-null DTMManager reference.
     */
    public DTMManager getDTMManager();
  
    /**
     * The root node of the <code>DTMIterator</code>, as specified when it
     * was created.  Note the root node is not the root node of the 
     * document tree, but the context node from where the iteration 
     * begins and ends.
     *
     * @return nodeHandle int Handle of the context node.
     */
    public int getRoot();
  
    /**
     * Reset the root node of the <code>DTMIterator</code>, overriding
     * the value specified when it was created.  Note the root node is
     * not the root node of the document tree, but the context node from
     * where the iteration begins.
     *
     * @param nodeHandle int Handle of the context node.
     * @param environment The environment object.  
     * The environment in which this iterator operates, which should provide:
     * <ul>
     * <li>a node (the context node... same value as "root" defined below) </li>
     * <li>a pair of non-zero positive integers (the context position and the context size) </li>
     * <li>a set of variable bindings </li>
     * <li>a function library </li>
     * <li>the set of namespace declarations in scope for the expression.</li>
     * <ul>
     * 
     * <p>At this time the exact implementation of this environment is application 
     * dependent.  Probably a proper interface will be created fairly soon.</p>
     * 
     */
    public void setRoot(int nodeHandle, Object environment);
    
    /**
     * Reset the iterator to the start. After resetting, the next node returned
     * will be the root node -- or, if that's filtered out, the first node
     * within the root's subtree which is _not_ skipped by the filters.
     */
    public void reset();
  
    /**
     * This attribute determines which node types are presented via the
     * iterator. The available set of constants is defined above.  
     * Nodes not accepted by
     * <code>whatToShow</code> will be skipped, but their children may still
     * be considered.
     *
     * @return one of the SHOW_XXX constants, or several ORed together.
     */
    public int getWhatToShow();
  
    /**
     * <p>The value of this flag determines whether the children of entity
     * reference nodes are visible to the iterator. If false, they  and
     * their descendants will be rejected. Note that this rejection takes
     * precedence over <code>whatToShow</code> and the filter. </p>
     * 
     * <p> To produce a view of the document that has entity references
     * expanded and does not expose the entity reference node itself, use
     * the <code>whatToShow</code> flags to hide the entity reference node
     * and set <code>expandEntityReferences</code> to true when creating the
     * iterator. To produce a view of the document that has entity reference
     * nodes but no entity expansion, use the <code>whatToShow</code> flags
     * to show the entity reference node and set
     * <code>expandEntityReferences</code> to false.</p>
     *
     * <p>NOTE: In Xalan's use of DTM we will generally have fully expanded
     * entity references when the document tree was built, and thus this
     * flag will have no effect.</p>
     *
     * @return true if entity references will be expanded.  */
    public boolean getExpandEntityReferences();
  
    /**
     * Returns the next node in the set and advances the position of the
     * iterator in the set. After a <code>DTMIterator</code> has setRoot called,
     * the first call to <code>nextNode()</code> returns that root or (if it
     * is rejected by the filters) the first node within its subtree which is
     * not filtered out.
     * @return The next node handle in the set being iterated over, or
     *  <code>DTM.NULL</code> if there are no more members in that set.
     */
    public int nextNode();
  
    /**
     * Returns the previous node in the set and moves the position of the
     * <code>DTMIterator</code> backwards in the set.
     * @return The previous node handle in the set being iterated over,
     *   or <code>DTM.NULL</code> if there are no more members in that set.
     */
    public int previousNode();
  
    /**
     * Detaches the <code>DTMIterator</code> from the set which it iterated
     * over, releasing any computational resources and placing the iterator
     * in the INVALID state. After <code>detach</code> has been invoked,
     * calls to <code>nextNode</code> or <code>previousNode</code> will
     * raise a runtime exception.
     */
    public void detach();
    
    /**
     * Specify if it's OK for detach to release the iterator for reuse.
     * 
     * @param allowRelease true if it is OK for detach to release this iterator 
     * for pooling.
     */
    public void allowDetachToRelease(boolean allowRelease);
  
    /**
     * Get the current node in the iterator. Note that this differs from
     * the DOM's NodeIterator, where the current position lies between two
     * nodes (as part of the maintain-relative-position semantic).
     *
     * @return The current node handle, or -1.
     */
    public int getCurrentNode();
  
    /**
     * Tells if this NodeSetDTM is "fresh", in other words, if
     * the first nextNode() that is called will return the
     * first node in the set.
     *
     * @return true if the iteration of this list has not yet begun.
     */
    public boolean isFresh();
  
    //========= Random Access ==========
  
    /**
     * If setShouldCacheNodes(true) is called, then nodes will
     * be cached, enabling random access, and giving the ability to do 
     * sorts and the like.  They are not cached by default.
     *
     * %REVIEW% Shouldn't the other random-access methods throw an exception
     * if they're called on a DTMIterator with this flag set false?
     *
     * @param b true if the nodes should be cached.
     */
    public void setShouldCacheNodes(boolean b);
    
    /**
     * Tells if this iterator can have nodes added to it or set via 
     * the <code>setItem(int node, int index)</code> method.
     * 
     * @return True if the nodelist can be mutated.
     */
    public boolean isMutable();
  
    /** Get the current position within the cached list, which is one
     * less than the next nextNode() call will retrieve.  i.e. if you
     * call getCurrentPos() and the return is 0, the next fetch will
     * take place at index 1.
     *
     * @return The position of the iteration.
     */
    public int getCurrentPos();
  
    /**
     * If an index is requested, NodeSetDTM will call this method
     * to run the iterator to the index.  By default this sets
     * m_next to the index.  If the index argument is -1, this
     * signals that the iterator should be run to the end and
     * completely fill the cache.
     *
     * @param index The index to run to, or -1 if the iterator should be run
     *              to the end.
     */
    public void runTo(int index);
  
    /**
     * Set the current position in the node set.
     * 
     * @param i Must be a valid index.
     */
    public void setCurrentPos(int i);
  
    /**
     * Returns the <code>node handle</code> of an item in the collection. If
     * <code>index</code> is greater than or equal to the number of nodes in
     * the list, this returns <code>null</code>.
     *
     * @param index of the item.
     * @return The node handle at the <code>index</code>th position in the
     *   <code>DTMIterator</code>, or <code>-1</code> if that is not a valid
     *   index.
     */
    public int item(int index);
    
    /**
     * Sets the node at the specified index of this vector to be the
     * specified node. The previous component at that position is discarded.
     *
     * <p>The index must be a value greater than or equal to 0 and less
     * than the current size of the vector.  
     * The iterator must be in cached mode.</p>
     * 
     * <p>Meant to be used for sorted iterators.</p>
     *
     * @param node Node to set
     * @param index Index of where to set the node
     */
    public void setItem(int node, int index);
    
    /**
     * The number of nodes in the list. The range of valid child node indices
     * is 0 to <code>length-1</code> inclusive. Note that this requires running
     * the iterator to completion, and presumably filling the cache.
     *
     * @return The number of nodes in the list.
     */
    public int getLength();
      
    //=========== Cloning operations. ============
    
    /**
     * Get a cloned Iterator that is reset to the start of the iteration.
     *
     * @return A clone of this iteration that has been reset.
     *
     * @throws CloneNotSupportedException
     */
    public DTMIterator cloneWithReset() throws CloneNotSupportedException;
  
    /**
     * Get a clone of this iterator, but don't reset the iteration in the 
     * process, so that it may be used from the current position.
     *
     * @return A clone of this object.
     *
     * @throws CloneNotSupportedException
     */
    public Object clone() throws CloneNotSupportedException;
    
    /**
     * Returns true if all the nodes in the iteration well be returned in document 
     * order.
     * 
     * @return true if all the nodes in the iteration well be returned in document 
     * order.
     */
    public boolean isDocOrdered();
    
    /**
     * Returns the axis being iterated, if it is known.
     * 
     * @return Axis.CHILD, etc., or -1 if the axis is not known or is of multiple 
     * types.
     */
    public int getAxis();
  
  }
  