1. /*

  2.  * The Apache Software License, Version 1.1

  3.  *

  4.  *

  5.  * Copyright (c) 1999 The Apache Software Foundation.  All rights 

  6.  * reserved.

  7.  *

  8.  * Redistribution and use in source and binary forms, with or without

  9.  * modification, are permitted provided that the following conditions

  10.  * are met:

  11.  *

  12.  * 1. Redistributions of source code must retain the above copyright

  13.  *    notice, this list of conditions and the following disclaimer. 

  14.  *

  15.  * 2. Redistributions in binary form must reproduce the above copyright

  16.  *    notice, this list of conditions and the following disclaimer in

  17.  *    the documentation and/or other materials provided with the

  18.  *    distribution.

  19.  *

  20.  * 3. The end-user documentation included with the redistribution,

  21.  *    if any, must include the following acknowledgment:  

  22.  *       "This product includes software developed by the

  23.  *        Apache Software Foundation (http://www.apache.org/)."

  24.  *    Alternately, this acknowledgment may appear in the software itself,

  25.  *    if and wherever such third-party acknowledgments normally appear.

  26.  *

  27.  * 4. The names "Xalan" and "Apache Software Foundation" must

  28.  *    not be used to endorse or promote products derived from this

  29.  *    software without prior written permission. For written 

  30.  *    permission, please contact apache@apache.org.

  31.  *

  32.  * 5. Products derived from this software may not be called "Apache",

  33.  *    nor may "Apache" appear in their name, without prior written

  34.  *    permission of the Apache Software Foundation.

  35.  *

  36.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED

  37.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

  38.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

  39.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR

  40.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

  41.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

  42.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

  43.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

  44.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

  45.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT

  46.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

  47.  * SUCH DAMAGE.

  48.  * ====================================================================

  49.  *

  50.  * This software consists of voluntary contributions made by many

  51.  * individuals on behalf of the Apache Software Foundation and was

  52.  * originally based on software copyright (c) 1999, Lotus

  53.  * Development Corporation., http://www.lotus.com.  For more

  54.  * information on the Apache Software Foundation, please see

  55.  * <http://www.apache.org/>.

  56.  */

  57. package org.apache.xpath.axes;

  58. 

  59. import org.apache.xpath.XPathContext;

  60. import org.apache.xml.utils.PrefixResolver;

  61. import org.apache.xpath.compiler.Compiler;

  62. import org.apache.xml.dtm.DTM;

  63. import org.apache.xml.dtm.DTMIterator;

  64. import org.apache.xml.dtm.Axis;

  65. 

  66. /**

  67.  * <meta name="usage" content="internal"/>

  68.  * This class iterates over set of nodes that needs to be sorted.

  69.  */

  70. public class WalkingIteratorSorted extends WalkingIterator

  71. {

  72. 

  73. //  /** True if the nodes will be found in document order */

  74. //  protected boolean m_inNaturalOrder = false;

  75.   

  76.   /** True if the nodes will be found in document order, and this can 

  77.    * be determined statically. */

  78.   protected boolean m_inNaturalOrderStatic = false;

  79. 

  80.   /**

  81.    * Create a WalkingIteratorSorted object.

  82.    *

  83.    * @param nscontext The namespace context for this iterator,

  84.    * should be OK if null.

  85.    */

  86.   public WalkingIteratorSorted(PrefixResolver nscontext)

  87.   {

  88.     super(nscontext);

  89.   }

  90. 

  91.   /**

  92.    * Create a WalkingIterator iterator, including creation

  93.    * of step walkers from the opcode list, and call back

  94.    * into the Compiler to create predicate expressions.

  95.    *

  96.    * @param compiler The Compiler which is creating

  97.    * this expression.

  98.    * @param opPos The position of this iterator in the

  99.    * opcode list from the compiler.

  100.    * @param shouldLoadWalkers True if walkers should be

  101.    * loaded, or false if this is a derived iterator and

  102.    * it doesn't wish to load child walkers.

  103.    *

  104.    * @throws javax.xml.transform.TransformerException

  105.    */

  106.   WalkingIteratorSorted(

  107.           Compiler compiler, int opPos, int analysis, boolean shouldLoadWalkers)

  108.             throws javax.xml.transform.TransformerException

  109.   {

  110.     super(compiler, opPos, analysis, shouldLoadWalkers);

  111.   }

  112.   

  113.   /**

  114.    * Returns true if all the nodes in the iteration well be returned in document 

  115.    * order.

  116.    * 

  117.    * @return true as a default.

  118.    */

  119.   public boolean isDocOrdered()

  120.   {

  121.     return m_inNaturalOrderStatic;

  122.   }

  123. 

  124.     

  125.   /**

  126.    * Tell if the nodeset can be walked in doc order, via static analysis. 

  127.    *

  128.    *

  129.    * @return true if the nodeset can be walked in doc order, without sorting.

  130.    */

  131.   boolean canBeWalkedInNaturalDocOrderStatic()

  132.   {

  133. 

  134.     if (null != m_firstWalker)

  135.     {

  136.       AxesWalker walker = m_firstWalker;

  137.       int prevAxis = -1;

  138.       boolean prevIsSimpleDownAxis = true;

  139. 

  140.       for(int i = 0; null != walker; i++)

  141.       {

  142.         int axis = walker.getAxis();

  143.         

  144.         if(walker.isDocOrdered())

  145.         {

  146.           boolean isSimpleDownAxis = ((axis == Axis.CHILD)

  147.                                    || (axis == Axis.SELF)

  148.                                    || (axis == Axis.ROOT));

  149.           // Catching the filtered list here is only OK because

  150.           // FilterExprWalker#isDocOrdered() did the right thing.

  151.           if(isSimpleDownAxis || (axis == -1))

  152.             walker = walker.getNextWalker();

  153.           else

  154.           {

  155.             boolean isLastWalker = (null == walker.getNextWalker());

  156.             if(isLastWalker)

  157.             {

  158.               if(walker.isDocOrdered() && (axis == Axis.DESCENDANT || 

  159.                  axis == Axis.DESCENDANTORSELF || axis == Axis.DESCENDANTSFROMROOT

  160.                  || axis == Axis.DESCENDANTSORSELFFROMROOT) || (axis == Axis.ATTRIBUTE))

  161.                 return true;

  162.             }

  163.             return false;

  164.           }

  165.         }

  166.         else

  167.           return false;

  168.       }

  169.       return true;

  170.     }

  171.     return false;

  172.   }

  173. 

  174. 

  175. //  /**

  176. //   * NEEDSDOC Method canBeWalkedInNaturalDocOrder 

  177. //   *

  178. //   *

  179. //   * NEEDSDOC (canBeWalkedInNaturalDocOrder) @return

  180. //   */

  181. //  boolean canBeWalkedInNaturalDocOrder()

  182. //  {

  183. //

  184. //    if (null != m_firstWalker)

  185. //    {

  186. //      AxesWalker walker = m_firstWalker;

  187. //      int prevAxis = -1;

  188. //      boolean prevIsSimpleDownAxis = true;

  189. //

  190. //      for(int i = 0; null != walker; i++)

  191. //      {

  192. //        int axis = walker.getAxis();

  193. //        

  194. //        if(walker.isDocOrdered())

  195. //        {

  196. //          boolean isSimpleDownAxis = ((axis == Axis.CHILD)

  197. //                                   || (axis == Axis.SELF)

  198. //                                   || (axis == Axis.ROOT));

  199. //          // Catching the filtered list here is only OK because

  200. //          // FilterExprWalker#isDocOrdered() did the right thing.

  201. //          if(isSimpleDownAxis || (axis == -1))

  202. //            walker = walker.getNextWalker();

  203. //          else

  204. //          {

  205. //            boolean isLastWalker = (null == walker.getNextWalker());

  206. //            if(isLastWalker)

  207. //            {

  208. //              if(walker.isDocOrdered() && (axis == Axis.DESCENDANT || 

  209. //                 axis == Axis.DESCENDANTORSELF || axis == Axis.DESCENDANTSFROMROOT

  210. //                 || axis == Axis.DESCENDANTSORSELFFROMROOT) || (axis == Axis.ATTRIBUTE))

  211. //                return true;

  212. //            }

  213. //            return false;

  214. //          }

  215. //        }

  216. //        else

  217. //          return false;

  218. //      }

  219. //      return true;

  220. //    }

  221. //    return false;

  222. //  }

  223.   

  224.   /**

  225.    * This function is used to perform some extra analysis of the iterator.

  226.    * 

  227.    * @param vars List of QNames that correspond to variables.  This list 

  228.    * should be searched backwards for the first qualified name that 

  229.    * corresponds to the variable reference qname.  The position of the 

  230.    * QName in the vector from the start of the vector will be its position 

  231.    * in the stack frame (but variables above the globalsTop value will need 

  232.    * to be offset to the current stack frame).

  233.    */

  234.   public void fixupVariables(java.util.Vector vars, int globalsSize)

  235.   {

  236.     super.fixupVariables(vars, globalsSize);

  237. 

  238.     int analysis = getAnalysisBits();

  239.     if(WalkerFactory.isNaturalDocOrder(analysis))

  240.     {

  241.     	m_inNaturalOrderStatic = true;

  242.     }

  243.     else

  244.     {

  245.     	m_inNaturalOrderStatic = false;

  246.     	// System.out.println("Setting natural doc order to false: "+

  247.     	//    WalkerFactory.getAnalysisString(analysis));

  248.     }

  249.     

  250.   }

  251. 

  252. }