1 /*
   2  * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.

   3  */
   4 /*
   5  * Licensed to the Apache Software Foundation (ASF) under one or more
   6  * contributor license agreements.  See the NOTICE file distributed with
   7  * this work for additional information regarding copyright ownership.
   8  * The ASF licenses this file to You under the Apache License, Version 2.0
   9  * (the "License"); you may not use this file except in compliance with
  10  * the License.  You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20 
  21 package com.sun.org.apache.xpath.internal.axes;
  22 
  23 import com.sun.org.apache.xml.internal.dtm.Axis;
  24 import com.sun.org.apache.xml.internal.dtm.DTM;
  25 import com.sun.org.apache.xml.internal.dtm.DTMIterator;
  26 import com.sun.org.apache.xml.internal.utils.QName;
  27 import com.sun.org.apache.xpath.internal.Expression;
  28 import com.sun.org.apache.xpath.internal.ExpressionOwner;
  29 import com.sun.org.apache.xpath.internal.XPathVisitor;
  30 import com.sun.org.apache.xpath.internal.compiler.Compiler;
  31 import com.sun.org.apache.xpath.internal.compiler.OpCodes;
  32 import com.sun.org.apache.xpath.internal.compiler.OpMap;
  33 import java.util.List;
  34 
  35 /**
  36  * This class extends NodeSetDTM, which implements DTMIterator,
  37  * and fetches nodes one at a time in document order based on a XPath
  38  * <a href="http://www.w3.org/TR/xpath#NT-UnionExpr">UnionExpr</a>.
  39  * As each node is iterated via nextNode(), the node is also stored
  40  * in the NodeVector, so that previousNode() can easily be done.
  41  * @xsl.usage advanced
  42  * @LastModified: Oct 2017
  43  */
  44 public class UnionPathIterator extends LocPathIterator
  45         implements Cloneable, DTMIterator, java.io.Serializable, PathComponent
  46 {
  47     static final long serialVersionUID = -3910351546843826781L;
  48 
  49   /**
  50    * Constructor to create an instance which you can add location paths to.
  51    */
  52   public UnionPathIterator()
  53   {
  54 
  55     super();
  56 
  57     // m_mutable = false;
  58     // m_cacheNodes = false;
  59     m_iterators = null;
  60     m_exprs = null;
  61   }
  62 
  63   /**
  64    * Initialize the context values for this expression
  65    * after it is cloned.
  66    *
  67    * @param context The XPath runtime context for this
  68    * transformation.
  69    */
  70   public void setRoot(int context, Object environment)
  71   {
  72     super.setRoot(context, environment);
  73 
  74     try
  75     {
  76       if (null != m_exprs)
  77       {
  78         int n = m_exprs.length;
  79         DTMIterator newIters[] = new DTMIterator[n];
  80 
  81         for (int i = 0; i < n; i++)
  82         {
  83           DTMIterator iter = m_exprs[i].asIterator(m_execContext, context);
  84           newIters[i] = iter;
  85           iter.nextNode();
  86         }
  87         m_iterators = newIters;
  88       }
  89     }
  90     catch(Exception e)
  91     {
  92       throw new com.sun.org.apache.xml.internal.utils.WrappedRuntimeException(e);
  93     }
  94   }
  95 
  96   /**
  97    * Add an iterator to the union list.
  98    *
  99    * @param expr non-null reference to a location path iterator.
 100    */
 101   public void addIterator(DTMIterator expr)
 102   {
 103 
 104     // Increase array size by only 1 at a time.  Fix this
 105     // if it looks to be a problem.
 106     if (null == m_iterators)
 107     {
 108       m_iterators = new DTMIterator[1];
 109       m_iterators[0] = expr;
 110     }
 111     else
 112     {
 113       DTMIterator[] exprs = m_iterators;
 114       int len = m_iterators.length;
 115 
 116       m_iterators = new DTMIterator[len + 1];
 117 
 118       System.arraycopy(exprs, 0, m_iterators, 0, len);
 119 
 120       m_iterators[len] = expr;
 121     }
 122     expr.nextNode();
 123     if(expr instanceof Expression)
 124         ((Expression)expr).exprSetParent(this);
 125   }
 126 
 127   /**
 128    *  Detaches the iterator from the set which it iterated over, releasing
 129    * any computational resources and placing the iterator in the INVALID
 130    * state. After<code>detach</code> has been invoked, calls to
 131    * <code>nextNode</code> or<code>previousNode</code> will raise the
 132    * exception INVALID_STATE_ERR.
 133    */
 134   public void detach()
 135   {
 136           if(m_allowDetach && null != m_iterators){
 137                   int n = m_iterators.length;
 138                   for(int i = 0; i < n; i++)
 139                   {
 140                           m_iterators[i].detach();
 141                   }
 142                   m_iterators = null;
 143           }
 144   }
 145 
 146 
 147   /**
 148    * Create a UnionPathIterator object, including creation
 149    * of location path iterators from the opcode list, and call back
 150    * into the Compiler to create predicate expressions.
 151    *
 152    * @param compiler The Compiler which is creating
 153    * this expression.
 154    * @param opPos The position of this iterator in the
 155    * opcode list from the compiler.
 156    *
 157    * @throws javax.xml.transform.TransformerException
 158    */
 159   public UnionPathIterator(Compiler compiler, int opPos)
 160           throws javax.xml.transform.TransformerException
 161   {
 162 
 163     super();
 164 
 165     opPos = OpMap.getFirstChildPos(opPos);
 166 
 167     loadLocationPaths(compiler, opPos, 0);
 168   }
 169 
 170   /**
 171    * This will return an iterator capable of handling the union of paths given.
 172    *
 173    * @param compiler The Compiler which is creating
 174    * this expression.
 175    * @param opPos The position of this iterator in the
 176    * opcode list from the compiler.
 177    *
 178    * @return Object that is derived from LocPathIterator.
 179    *
 180    * @throws javax.xml.transform.TransformerException
 181    */
 182   public static LocPathIterator createUnionIterator(Compiler compiler, int opPos)
 183           throws javax.xml.transform.TransformerException
 184   {
 185         // For the moment, I'm going to first create a full UnionPathIterator, and
 186         // then see if I can reduce it to a UnionChildIterator.  It would obviously
 187         // be more effecient to just test for the conditions for a UnionChildIterator,
 188         // and then create that directly.
 189         UnionPathIterator upi = new UnionPathIterator(compiler, opPos);
 190         int nPaths = upi.m_exprs.length;
 191         boolean isAllChildIterators = true;
 192         for(int i = 0; i < nPaths; i++)
 193         {
 194                 LocPathIterator lpi = upi.m_exprs[i];
 195 
 196                 if(lpi.getAxis() != Axis.CHILD)
 197                 {
 198                         isAllChildIterators = false;
 199                         break;
 200                 }
 201                 else
 202                 {
 203                         // check for positional predicates or position function, which won't work.
 204                         if(HasPositionalPredChecker.check(lpi))
 205                         {
 206                                 isAllChildIterators = false;
 207                                 break;
 208                         }
 209                 }
 210         }
 211         if(isAllChildIterators)
 212         {
 213                 UnionChildIterator uci = new UnionChildIterator();
 214 
 215                 for(int i = 0; i < nPaths; i++)
 216                 {
 217                         PredicatedNodeTest lpi = upi.m_exprs[i];
 218                         // I could strip the lpi down to a pure PredicatedNodeTest, but
 219                         // I don't think it's worth it.  Note that the test can be used
 220                         // as a static object... so it doesn't have to be cloned.
 221                         uci.addNodeTest(lpi);
 222                 }
 223                 return uci;
 224 
 225         }
 226         else
 227                 return upi;
 228   }
 229 
 230   /**
 231    * Get the analysis bits for this walker, as defined in the WalkerFactory.
 232    * @return One of WalkerFactory#BIT_DESCENDANT, etc.
 233    */
 234   public int getAnalysisBits()
 235   {
 236     int bits = 0;
 237 
 238     if (m_exprs != null)
 239     {
 240       int n = m_exprs.length;
 241 
 242       for (int i = 0; i < n; i++)
 243       {
 244         int bit = m_exprs[i].getAnalysisBits();
 245         bits |= bit;
 246       }
 247     }
 248 
 249     return bits;
 250   }
 251 
 252   /**
 253    * Read the object from a serialization stream.
 254    *
 255    * @param stream Input stream to read from
 256    *
 257    * @throws java.io.IOException
 258    * @throws javax.xml.transform.TransformerException
 259    */
 260   private void readObject(java.io.ObjectInputStream stream)
 261           throws java.io.IOException, javax.xml.transform.TransformerException
 262   {
 263     try
 264     {
 265       stream.defaultReadObject();
 266       m_clones =  new IteratorPool(this);
 267     }
 268     catch (ClassNotFoundException cnfe)
 269     {
 270       throw new javax.xml.transform.TransformerException(cnfe);
 271     }
 272   }
 273 
 274   /**
 275    * Get a cloned LocPathIterator that holds the same
 276    * position as this iterator.
 277    *
 278    * @return A clone of this iterator that holds the same node position.
 279    *
 280    * @throws CloneNotSupportedException
 281    */
 282   public Object clone() throws CloneNotSupportedException
 283   {
 284 
 285     UnionPathIterator clone = (UnionPathIterator) super.clone();
 286     if (m_iterators != null)
 287     {
 288       int n = m_iterators.length;
 289 
 290       clone.m_iterators = new DTMIterator[n];
 291 
 292       for (int i = 0; i < n; i++)
 293       {
 294         clone.m_iterators[i] = (DTMIterator)m_iterators[i].clone();
 295       }
 296     }
 297 
 298     return clone;
 299   }
 300 
 301 
 302   /**
 303    * Create a new location path iterator.
 304    *
 305    * @param compiler The Compiler which is creating
 306    * this expression.
 307    * @param opPos The position of this iterator in the
 308    *
 309    * @return New location path iterator.
 310    *
 311    * @throws javax.xml.transform.TransformerException
 312    */
 313   protected LocPathIterator createDTMIterator(
 314           Compiler compiler, int opPos) throws javax.xml.transform.TransformerException
 315   {
 316     LocPathIterator lpi = (LocPathIterator)WalkerFactory.newDTMIterator(compiler, opPos,
 317                                       (compiler.getLocationPathDepth() <= 0));
 318     return lpi;
 319   }
 320 
 321   /**
 322    * Initialize the location path iterators.  Recursive.
 323    *
 324    * @param compiler The Compiler which is creating
 325    * this expression.
 326    * @param opPos The position of this iterator in the
 327    * opcode list from the compiler.
 328    * @param count The insert position of the iterator.
 329    *
 330    * @throws javax.xml.transform.TransformerException
 331    */
 332   protected void loadLocationPaths(Compiler compiler, int opPos, int count)
 333           throws javax.xml.transform.TransformerException
 334   {
 335 
 336     // TODO: Handle unwrapped FilterExpr
 337     int steptype = compiler.getOp(opPos);
 338 
 339     if (steptype == OpCodes.OP_LOCATIONPATH)
 340     {
 341       loadLocationPaths(compiler, compiler.getNextOpPos(opPos), count + 1);
 342 
 343       m_exprs[count] = createDTMIterator(compiler, opPos);
 344       m_exprs[count].exprSetParent(this);
 345     }
 346     else
 347     {
 348 
 349       // Have to check for unwrapped functions, which the LocPathIterator
 350       // doesn't handle.
 351       switch (steptype)
 352       {
 353       case OpCodes.OP_VARIABLE :
 354       case OpCodes.OP_EXTFUNCTION :
 355       case OpCodes.OP_FUNCTION :
 356       case OpCodes.OP_GROUP :
 357         loadLocationPaths(compiler, compiler.getNextOpPos(opPos), count + 1);
 358 
 359         WalkingIterator iter =
 360           new WalkingIterator(compiler.getNamespaceContext());
 361         iter.exprSetParent(this);
 362 
 363         if(compiler.getLocationPathDepth() <= 0)
 364           iter.setIsTopLevel(true);
 365 
 366         iter.m_firstWalker = new com.sun.org.apache.xpath.internal.axes.FilterExprWalker(iter);
 367 
 368         iter.m_firstWalker.init(compiler, opPos, steptype);
 369 
 370         m_exprs[count] = iter;
 371         break;
 372       default :
 373         m_exprs = new LocPathIterator[count];
 374       }
 375     }
 376   }
 377 
 378   /**
 379    *  Returns the next node in the set and advances the position of the
 380    * iterator in the set. After a DTMIterator is created, the first call
 381    * to nextNode() returns the first node in the set.
 382    * @return  The next <code>Node</code> in the set being iterated over, or
 383    *   <code>null</code> if there are no more members in that set.
 384    */
 385   public int nextNode()
 386   {
 387         if(m_foundLast)
 388                 return DTM.NULL;
 389 
 390     // Loop through the iterators getting the current fetched
 391     // node, and get the earliest occuring in document order
 392     int earliestNode = DTM.NULL;
 393 
 394     if (null != m_iterators)
 395     {
 396       int n = m_iterators.length;
 397       int iteratorUsed = -1;
 398 
 399       for (int i = 0; i < n; i++)
 400       {
 401         int node = m_iterators[i].getCurrentNode();
 402 
 403         if (DTM.NULL == node)
 404           continue;
 405         else if (DTM.NULL == earliestNode)
 406         {
 407           iteratorUsed = i;
 408           earliestNode = node;
 409         }
 410         else
 411         {
 412           if (node == earliestNode)
 413           {
 414 
 415             // Found a duplicate, so skip past it.
 416             m_iterators[i].nextNode();
 417           }
 418           else
 419           {
 420             DTM dtm = getDTM(node);
 421 
 422             if (dtm.isNodeAfter(node, earliestNode))
 423             {
 424               iteratorUsed = i;
 425               earliestNode = node;
 426             }
 427           }
 428         }
 429       }
 430 
 431       if (DTM.NULL != earliestNode)
 432       {
 433         m_iterators[iteratorUsed].nextNode();
 434 
 435         incrementCurrentPos();
 436       }
 437       else
 438         m_foundLast = true;
 439     }
 440 
 441     m_lastFetched = earliestNode;
 442 
 443     return earliestNode;
 444   }
 445 
 446   /**
 447    * This function is used to fixup variables from QNames to stack frame
 448    * indexes at stylesheet build time.
 449    * @param vars List of QNames that correspond to variables.  This list
 450    * should be searched backwards for the first qualified name that
 451    * corresponds to the variable reference qname.  The position of the
 452    * QName in the vector from the start of the vector will be its position
 453    * in the stack frame (but variables above the globalsTop value will need
 454    * to be offset to the current stack frame).
 455    */
 456   public void fixupVariables(List<QName> vars, int globalsSize)
 457   {
 458     for (int i = 0; i < m_exprs.length; i++)
 459     {
 460       m_exprs[i].fixupVariables(vars, globalsSize);
 461     }
 462 
 463   }
 464 
 465   /**
 466    * The location path iterators, one for each
 467    * <a href="http://www.w3.org/TR/xpath#NT-LocationPath">location
 468    * path</a> contained in the union expression.
 469    * @serial
 470    */
 471   protected LocPathIterator[] m_exprs;
 472 
 473 
 474   /**
 475    * The location path iterators, one for each
 476    * <a href="http://www.w3.org/TR/xpath#NT-LocationPath">location
 477    * path</a> contained in the union expression.
 478    * @serial
 479    */
 480   protected DTMIterator[] m_iterators;
 481 
 482   /**
 483    * Returns the axis being iterated, if it is known.
 484    *
 485    * @return Axis.CHILD, etc., or -1 if the axis is not known or is of multiple
 486    * types.
 487    */
 488   public int getAxis()
 489   {
 490     // Could be smarter.
 491     return -1;
 492   }
 493 
 494   class iterOwner implements ExpressionOwner
 495   {
 496         int m_index;
 497 
 498         iterOwner(int index)
 499         {
 500                 m_index = index;
 501         }
 502 
 503     /**
 504      * @see ExpressionOwner#getExpression()
 505      */
 506     public Expression getExpression()
 507     {
 508       return m_exprs[m_index];
 509     }
 510 
 511     /**
 512      * @see ExpressionOwner#setExpression(Expression)
 513      */
 514     public void setExpression(Expression exp)
 515     {
 516 
 517         if(!(exp instanceof LocPathIterator))
 518         {
 519                 // Yuck.  Need FilterExprIter.  Or make it so m_exprs can be just
 520                 // plain expressions?
 521                 WalkingIterator wi = new WalkingIterator(getPrefixResolver());
 522                 FilterExprWalker few = new FilterExprWalker(wi);
 523                 wi.setFirstWalker(few);
 524                 few.setInnerExpression(exp);
 525                 wi.exprSetParent(UnionPathIterator.this);
 526                 few.exprSetParent(wi);
 527                 exp.exprSetParent(few);
 528                 exp = wi;
 529         }
 530         else
 531                 exp.exprSetParent(UnionPathIterator.this);
 532         m_exprs[m_index] = (LocPathIterator)exp;
 533     }
 534 
 535   }
 536 
 537   /**
 538    * @see com.sun.org.apache.xpath.internal.XPathVisitable#callVisitors(ExpressionOwner, XPathVisitor)
 539    */
 540   public void callVisitors(ExpressionOwner owner, XPathVisitor visitor)
 541   {
 542                 if(visitor.visitUnionPath(owner, this))
 543                 {
 544                         if(null != m_exprs)
 545                         {
 546                                 int n = m_exprs.length;
 547                                 for(int i = 0; i < n; i++)
 548                                 {
 549                                         m_exprs[i].callVisitors(new iterOwner(i), visitor);
 550                                 }
 551                         }
 552                 }
 553   }
 554 
 555     /**
 556      * @see Expression#deepEquals(Expression)
 557      */
 558     public boolean deepEquals(Expression expr)
 559     {
 560       if (!super.deepEquals(expr))
 561             return false;
 562 
 563       UnionPathIterator upi = (UnionPathIterator) expr;
 564 
 565       if (null != m_exprs)
 566       {
 567         int n = m_exprs.length;
 568 
 569         if((null == upi.m_exprs) || (upi.m_exprs.length != n))
 570                 return false;
 571 
 572         for (int i = 0; i < n; i++)
 573         {
 574           if(!m_exprs[i].deepEquals(upi.m_exprs[i]))
 575                 return false;
 576         }
 577       }
 578       else if (null != upi.m_exprs)
 579       {
 580           return false;
 581       }
 582 
 583       return true;
 584     }
 585 
 586 
 587 }
--- EOF ---