1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one 3 * or more contributor license agreements. See the NOTICE file 4 * distributed with this work for additional information 5 * regarding copyright ownership. The ASF licenses this file 6 * to you under the Apache License, Version 2.0 (the "License"); 7 * you may not use this file except in compliance with the License. 8 * You may obtain a copy of the License at 9 * 10 * http://www.apache.org/licenses/LICENSE-2.0 11 * 12 * Unless required by applicable law or agreed to in writing, software 13 * distributed under the License is distributed on an "AS IS" BASIS, 14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 * See the License for the specific language governing permissions and 16 * limitations under the License. 17 */ 18 /* 19 * $Id: OneStepIterator.java 469314 2006-10-30 23:31:59Z minchau $ 20 */ 21 package org.apache.xpath.axes; 22 23 import org.apache.xml.dtm.DTM; 24 import org.apache.xml.dtm.DTMAxisIterator; 25 import org.apache.xml.dtm.DTMFilter; 26 import org.apache.xml.dtm.DTMIterator; 27 import org.apache.xpath.Expression; 28 import org.apache.xpath.XPathContext; 29 import org.apache.xpath.compiler.Compiler; 30 import org.apache.xpath.compiler.OpMap; 31 32 /** 33 * This class implements a general iterator for 34 * those LocationSteps with only one step, and perhaps a predicate. 35 * @see org.apache.xpath.axes#LocPathIterator 36 * @xsl.usage advanced 37 */ 38 public class OneStepIterator extends ChildTestIterator 39 { 40 static final long serialVersionUID = 4623710779664998283L; 41 /** The traversal axis from where the nodes will be filtered. */ 42 protected int m_axis = -1; 43 44 /** The DTM inner traversal class, that corresponds to the super axis. */ 45 protected DTMAxisIterator m_iterator; 46 47 /** 48 * Create a OneStepIterator object. 49 * 50 * @param compiler A reference to the Compiler that contains the op map. 51 * @param opPos The position within the op map, which contains the 52 * location path expression for this itterator. 53 * 54 * @throws javax.xml.transform.TransformerException 55 */ 56 OneStepIterator(Compiler compiler, int opPos, int analysis) 57 throws javax.xml.transform.TransformerException 58 { 59 super(compiler, opPos, analysis); 60 int firstStepPos = OpMap.getFirstChildPos(opPos); 61 62 m_axis = WalkerFactory.getAxisFromStep(compiler, firstStepPos); 63 64 } 65 66 67 /** 68 * Create a OneStepIterator object. 69 * 70 * @param iterator The DTM iterator which this iterator will use. 71 * @param axis One of Axis.Child, etc., or -1 if the axis is unknown. 72 * 73 * @throws javax.xml.transform.TransformerException 74 */ 75 public OneStepIterator(DTMAxisIterator iterator, int axis) 76 throws javax.xml.transform.TransformerException 77 { 78 super(null); 79 80 m_iterator = iterator; 81 m_axis = axis; 82 int whatToShow = DTMFilter.SHOW_ALL; 83 initNodeTest(whatToShow); 84 } 85 86 /** 87 * Initialize the context values for this expression 88 * after it is cloned. 89 * 90 * @param context The XPath runtime context for this 91 * transformation. 92 */ 93 public void setRoot(int context, Object environment) 94 { 95 super.setRoot(context, environment); 96 if(m_axis > -1) 97 m_iterator = m_cdtm.getAxisIterator(m_axis); 98 m_iterator.setStartNode(m_context); 99 } 100 101 /** 102 * Detaches the iterator from the set which it iterated over, releasing 103 * any computational resources and placing the iterator in the INVALID 104 * state. After<code>detach</code> has been invoked, calls to 105 * <code>nextNode</code> or<code>previousNode</code> will raise the 106 * exception INVALID_STATE_ERR. 107 */ 108 public void detach() 109 { 110 if(m_allowDetach) 111 { 112 if(m_axis > -1) 113 m_iterator = null; 114 115 // Always call the superclass detach last! 116 super.detach(); 117 } 118 } 119 120 /** 121 * Get the next node via getFirstAttribute && getNextAttribute. 122 */ 123 protected int getNextNode() 124 { 125 return m_lastFetched = m_iterator.next(); 126 } 127 128 /** 129 * Get a cloned iterator. 130 * 131 * @return A new iterator that can be used without mutating this one. 132 * 133 * @throws CloneNotSupportedException 134 */ 135 public Object clone() throws CloneNotSupportedException 136 { 137 // Do not access the location path itterator during this operation! 138 139 OneStepIterator clone = (OneStepIterator) super.clone(); 140 141 if(m_iterator != null) 142 { 143 clone.m_iterator = m_iterator.cloneIterator(); 144 } 145 return clone; 146 } 147 148 /** 149 * Get a cloned Iterator that is reset to the beginning 150 * of the query. 151 * 152 * @return A cloned NodeIterator set of the start of the query. 153 * 154 * @throws CloneNotSupportedException 155 */ 156 public DTMIterator cloneWithReset() throws CloneNotSupportedException 157 { 158 159 OneStepIterator clone = (OneStepIterator) super.cloneWithReset(); 160 clone.m_iterator = m_iterator; 161 162 return clone; 163 } 164 165 166 167 /** 168 * Tells if this is a reverse axes. Overrides AxesWalker#isReverseAxes. 169 * 170 * @return true for this class. 171 */ 172 public boolean isReverseAxes() 173 { 174 return m_iterator.isReverse(); 175 } 176 177 /** 178 * Get the current sub-context position. In order to do the 179 * reverse axes count, for the moment this re-searches the axes 180 * up to the predicate. An optimization on this is to cache 181 * the nodes searched, but, for the moment, this case is probably 182 * rare enough that the added complexity isn't worth it. 183 * 184 * @param predicateIndex The predicate index of the proximity position. 185 * 186 * @return The pridicate index, or -1. 187 */ 188 protected int getProximityPosition(int predicateIndex) 189 { 190 if(!isReverseAxes()) 191 return super.getProximityPosition(predicateIndex); 192 193 // A negative predicate index seems to occur with 194 // (preceding-sibling::*|following-sibling::*)/ancestor::*[position()]/*[position()] 195 // -sb 196 if(predicateIndex < 0) 197 return -1; 198 199 if (m_proximityPositions[predicateIndex] <= 0) 200 { 201 XPathContext xctxt = getXPathContext(); 202 try 203 { 204 OneStepIterator clone = (OneStepIterator) this.clone(); 205 206 int root = getRoot(); 207 xctxt.pushCurrentNode(root); 208 clone.setRoot(root, xctxt); 209 210 // clone.setPredicateCount(predicateIndex); 211 clone.m_predCount = predicateIndex; 212 213 // Count 'em all 214 int count = 1; 215 int next; 216 217 while (DTM.NULL != (next = clone.nextNode())) 218 { 219 count++; 220 } 221 222 m_proximityPositions[predicateIndex] += count; 223 } 224 catch (CloneNotSupportedException cnse) 225 { 226 227 // can't happen 228 } 229 finally 230 { 231 xctxt.popCurrentNode(); 232 } 233 } 234 235 return m_proximityPositions[predicateIndex]; 236 } 237 238 /** 239 * The number of nodes in the list. The range of valid child node indices 240 * is 0 to <code>length-1</code> inclusive. 241 * 242 * @return The number of nodes in the list, always greater or equal to zero. 243 */ 244 public int getLength() 245 { 246 if(!isReverseAxes()) 247 return super.getLength(); 248 249 // Tell if this is being called from within a predicate. 250 boolean isPredicateTest = (this == m_execContext.getSubContextList()); 251 252 // And get how many total predicates are part of this step. 253 int predCount = getPredicateCount(); 254 255 // If we have already calculated the length, and the current predicate 256 // is the first predicate, then return the length. We don't cache 257 // the anything but the length of the list to the first predicate. 258 if (-1 != m_length && isPredicateTest && m_predicateIndex < 1) 259 return m_length; 260 261 int count = 0; 262 263 XPathContext xctxt = getXPathContext(); 264 try 265 { 266 OneStepIterator clone = (OneStepIterator) this.cloneWithReset(); 267 268 int root = getRoot(); 269 xctxt.pushCurrentNode(root); 270 clone.setRoot(root, xctxt); 271 272 clone.m_predCount = m_predicateIndex; 273 274 int next; 275 276 while (DTM.NULL != (next = clone.nextNode())) 277 { 278 count++; 279 } 280 } 281 catch (CloneNotSupportedException cnse) 282 { 283 // can't happen 284 } 285 finally 286 { 287 xctxt.popCurrentNode(); 288 } 289 if (isPredicateTest && m_predicateIndex < 1) 290 m_length = count; 291 292 return count; 293 } 294 295 /** 296 * Count backwards one proximity position. 297 * 298 * @param i The predicate index. 299 */ 300 protected void countProximityPosition(int i) 301 { 302 if(!isReverseAxes()) 303 super.countProximityPosition(i); 304 else if (i < m_proximityPositions.length) 305 m_proximityPositions[i]--; 306 } 307 308 /** 309 * Reset the iterator. 310 */ 311 public void reset() 312 { 313 314 super.reset(); 315 if(null != m_iterator) 316 m_iterator.reset(); 317 } 318 319 /** 320 * Returns the axis being iterated, if it is known. 321 * 322 * @return Axis.CHILD, etc., or -1 if the axis is not known or is of multiple 323 * types. 324 */ 325 public int getAxis() 326 { 327 return m_axis; 328 } 329 330 /** 331 * @see Expression#deepEquals(Expression) 332 */ 333 public boolean deepEquals(Expression expr) 334 { 335 if(!super.deepEquals(expr)) 336 return false; 337 338 if(m_axis != ((OneStepIterator)expr).m_axis) 339 return false; 340 341 return true; 342 } 343 344 345 } 346
