PredicatedNodeTest


1   /*
2    * Copyright 1999-2004 The Apache Software Foundation.
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    *     http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  /*
17   * $Id: PredicatedNodeTest.java,v 1.15 2004/02/17 04:32:08 minchau Exp $
18   */
19  package com.sun.org.apache.xpath.internal.axes;
20  
21  import com.sun.org.apache.xml.internal.dtm.DTM;
22  import com.sun.org.apache.xml.internal.dtm.DTMIterator;
23  import com.sun.org.apache.xml.internal.utils.PrefixResolver;
24  import com.sun.org.apache.xpath.internal.Expression;
25  import com.sun.org.apache.xpath.internal.ExpressionOwner;
26  import com.sun.org.apache.xpath.internal.XPathContext;
27  import com.sun.org.apache.xpath.internal.XPathVisitor;
28  import com.sun.org.apache.xpath.internal.compiler.Compiler;
29  import com.sun.org.apache.xpath.internal.objects.XObject;
30  import com.sun.org.apache.xpath.internal.patterns.NodeTest;
31  
32  public abstract class PredicatedNodeTest extends NodeTest implements SubContextList
33  {
34  
35    /**
36     * Construct an AxesWalker using a LocPathIterator.
37     *
38     * @param locPathIterator non-null reference to the parent iterator.
39     */
40    PredicatedNodeTest(LocPathIterator locPathIterator)
41    {
42      m_lpi = locPathIterator;
43    }
44    
45    /**
46     * Construct an AxesWalker.  The location path iterator will have to be set
47     * before use.
48     */
49    PredicatedNodeTest()
50    {
51    }
52    
53    /**
54     * Read the object from a serialization stream.
55     *
56     * @param stream Input stream to read from
57     *
58     * @throws java.io.IOException
59     * @throws javax.xml.transform.TransformerException
60     */
61    private void readObject(java.io.ObjectInputStream   stream)
62            throws java.io.IOException  , javax.xml.transform.TransformerException  
63    {
64      try
65      {
66        stream.defaultReadObject();
67        m_predicateIndex = -1;
68        resetProximityPositions();
69      }
70      catch (ClassNotFoundException   cnfe)
71      {
72        throw new javax.xml.transform.TransformerException  (cnfe);
73      }
74    }
75    
76    /**
77     * Get a cloned PrdicatedNodeTest.
78     *
79     * @return A new PredicatedNodeTest that can be used without mutating this one.
80     *
81     * @throws CloneNotSupportedException
82     */
83    public Object   clone() throws CloneNotSupportedException  
84    {
85      // Do not access the location path itterator during this operation!
86      
87      PredicatedNodeTest clone = (PredicatedNodeTest) super.clone();
88  
89      if ((null != this.m_proximityPositions)
90              && (this.m_proximityPositions == clone.m_proximityPositions))
91      {
92        clone.m_proximityPositions = new int[this.m_proximityPositions.length];
93  
94        System.arraycopy(this.m_proximityPositions, 0,
95                         clone.m_proximityPositions, 0,
96                         this.m_proximityPositions.length);
97      }
98      
99      if(clone.m_lpi == this)
100       clone.m_lpi = (LocPathIterator)clone;
101 
102     return clone;
103   }
104   
105   // Only for clones for findLastPos.  See bug4638.
106   protected int m_predCount = -1;
107 
108   /**
109    * Get the number of predicates that this walker has.
110    *
111    * @return the number of predicates that this walker has.
112    */
113   public int getPredicateCount()
114   {
115     if(-1 == m_predCount)
116       return (null == m_predicates) ? 0 : m_predicates.length;
117     else
118       return m_predCount;
119   }
120 
121   /**
122    * Set the number of predicates that this walker has.  This does more 
123    * that one would think, as it creates a new predicate array of the 
124    * size of the count argument, and copies count predicates into the new 
125    * one from the old, and then reassigns the predicates value.  All this 
126    * to keep from having to have a predicate count value.
127    *
128    * @param count The number of predicates, which must be equal or less 
129    *               than the existing count.
130    */
131   public void setPredicateCount(int count)
132   {
133     if(count > 0)
134     {
135       Expression[] newPredicates = new Expression[count];
136       for (int i = 0; i < count; i++) 
137       {
138         newPredicates[i] = m_predicates[i];
139       }
140       m_predicates = newPredicates;
141     }
142     else
143       m_predicates = null;
144     
145   }
146 
147   /**
148    * Init predicate info.
149    *
150    * @param compiler The Compiler object that has information about this 
151    *                 walker in the op map.
152    * @param opPos The op code position of this location step.
153    *
154    * @throws javax.xml.transform.TransformerException
155    */
156   protected void initPredicateInfo(Compiler   compiler, int opPos)
157           throws javax.xml.transform.TransformerException  
158   {
159 
160     int pos = compiler.getFirstPredicateOpPos(opPos);
161 
162     if(pos > 0)
163     {
164       m_predicates = compiler.getCompiledPredicates(pos);
165       if(null != m_predicates)
166       {
167         for(int i = 0; i < m_predicates.length; i++)
168         {
169             m_predicates[i].exprSetParent(this);
170         }
171       }
172     }
173   }
174 
175   /**
176    * Get a predicate expression at the given index.
177    *
178    *
179    * @param index Index of the predicate.
180    *
181    * @return A predicate expression.
182    */
183   public Expression getPredicate(int index)
184   {
185     return m_predicates[index];
186   }
187   
188   /**
189    * Get the current sub-context position.
190    *
191    * @return The node position of this walker in the sub-context node list.
192    */
193   public int getProximityPosition()
194   {
195 
196     // System.out.println("getProximityPosition - m_predicateIndex: "+m_predicateIndex);
197     return getProximityPosition(m_predicateIndex);
198   }
199 
200   /**
201    * Get the current sub-context position.
202    *
203    * @param xctxt The XPath runtime context.
204    *
205    * @return The node position of this walker in the sub-context node list.
206    */
207   public int getProximityPosition(XPathContext xctxt)
208   {
209     return getProximityPosition();
210   }
211   
212   /**
213    * Get the index of the last node that can be itterated to.
214    *
215    *
216    * @param xctxt XPath runtime context.
217    *
218    * @return the index of the last node that can be itterated to.
219    */
220   public abstract int getLastPos(XPathContext xctxt);
221 
222   /**
223    * Get the current sub-context position.
224    *
225    * @param predicateIndex The index of the predicate where the proximity 
226    *                       should be taken from.
227    *
228    * @return The node position of this walker in the sub-context node list.
229    */
230   protected int getProximityPosition(int predicateIndex)
231   {
232     return (predicateIndex >= 0) ? m_proximityPositions[predicateIndex] : 0;
233   }
234 
235   /**
236    * Reset the proximity positions counts.
237    */
238   public void resetProximityPositions()
239   {
240     int nPredicates = getPredicateCount();
241     if (nPredicates > 0)
242     {
243       if (null == m_proximityPositions)
244         m_proximityPositions = new int[nPredicates];
245 
246       for (int i = 0; i < nPredicates; i++)
247       {
248         try
249         {
250           initProximityPosition(i);
251         }
252         catch(Exception   e)
253         {
254           // TODO: Fix this...
255           throw new com.sun.org.apache.xml.internal.utils.WrappedRuntimeException(e);
256         }
257       }
258     }
259   }
260 
261   /**
262    * Init the proximity position to zero for a forward axes.
263    *
264    * @param i The index into the m_proximityPositions array.
265    *
266    * @throws javax.xml.transform.TransformerException
267    */
268   public void initProximityPosition(int i) throws javax.xml.transform.TransformerException  
269   {
270     m_proximityPositions[i] = 0;
271   }
272 
273   /**
274    * Count forward one proximity position.
275    *
276    * @param i The index into the m_proximityPositions array, where the increment 
277    *          will occur.
278    */
279   protected void countProximityPosition(int i)
280   {
281     // Note that in the case of a UnionChildIterator, this may be a 
282     // static object and so m_proximityPositions may indeed be null!
283     int[] pp = m_proximityPositions;
284     if ((null != pp) && (i < pp.length))
285       pp[i]++;
286   }
287 
288   /**
289    * Tells if this is a reverse axes.
290    *
291    * @return false, unless a derived class overrides.
292    */
293   public boolean isReverseAxes()
294   {
295     return false;
296   }
297 
298   /**
299    * Get which predicate is executing.
300    *
301    * @return The current predicate index, or -1 if no predicate is executing.
302    */
303   public int getPredicateIndex()
304   {
305     return m_predicateIndex;
306   }
307 
308   /**
309    * Process the predicates.
310    *
311    * @param context The current context node.
312    * @param xctxt The XPath runtime context.
313    *
314    * @return the result of executing the predicate expressions.
315    *
316    * @throws javax.xml.transform.TransformerException
317    */
318   boolean executePredicates(int context, XPathContext xctxt)
319           throws javax.xml.transform.TransformerException  
320   {
321     
322     int nPredicates = getPredicateCount();
323     // System.out.println("nPredicates: "+nPredicates);
324     if (nPredicates == 0)
325       return true;
326 
327     PrefixResolver savedResolver = xctxt.getNamespaceContext();
328 
329     try
330     {
331       m_predicateIndex = 0;
332       xctxt.pushSubContextList(this);
333       xctxt.pushNamespaceContext(m_lpi.getPrefixResolver());
334       xctxt.pushCurrentNode(context);
335 
336       for (int i = 0; i < nPredicates; i++)
337       {
338         // System.out.println("Executing predicate expression - waiting count: "+m_lpi.getWaitingCount());
339         XObject pred = m_predicates[i].execute(xctxt);
340         // System.out.println("\nBack from executing predicate expression - waiting count: "+m_lpi.getWaitingCount());
341         // System.out.println("pred.getType(): "+pred.getType());
342         if (XObject.CLASS_NUMBER == pred.getType())
343         {
344           if (DEBUG_PREDICATECOUNTING)
345           {
346             System.out.flush();
347             System.out.println("\n===== start predicate count ========");
348             System.out.println("m_predicateIndex: " + m_predicateIndex);
349             // System.out.println("getProximityPosition(m_predicateIndex): "
350             //                   + getProximityPosition(m_predicateIndex));
351             System.out.println("pred.num(): " + pred.num());
352           }
353 
354           int proxPos = this.getProximityPosition(m_predicateIndex);
355           int predIndex = (int) pred.num();
356           if (proxPos != predIndex)
357           {
358             if (DEBUG_PREDICATECOUNTING)
359             {
360               System.out.println("\nnode context: "+nodeToString(context));
361               System.out.println("index predicate is false: "+proxPos);
362               System.out.println("\n===== end predicate count ========");
363             }
364             return false;
365           }
366           else if (DEBUG_PREDICATECOUNTING)
367           {
368             System.out.println("\nnode context: "+nodeToString(context));
369             System.out.println("index predicate is true: "+proxPos);
370             System.out.println("\n===== end predicate count ========");
371           }
372           
373           // If there is a proximity index that will not change during the 
374           // course of itteration, then we know there can be no more true 
375           // occurances of this predicate, so flag that we're done after 
376           // this.
377           //
378           // bugzilla 14365
379           // We can't set m_foundLast = true unless we're sure that -all-
380           // remaining parameters are stable, or else last() fails. Fixed so
381           // only sets m_foundLast if on the last predicate
382           if(m_predicates[i].isStableNumber() && i == nPredicates - 1)
383           {
384             m_foundLast = true;
385           }
386         }
387         else if (!pred.bool())
388           return false;
389 
390         countProximityPosition(++m_predicateIndex);
391       }
392     }
393     finally
394     {
395       xctxt.popCurrentNode();
396       xctxt.popNamespaceContext();
397       xctxt.popSubContextList();
398       m_predicateIndex = -1;
399     }
400 
401     return true;
402   }
403   
404   /**
405    * This function is used to fixup variables from QNames to stack frame 
406    * indexes at stylesheet build time.
407    * @param vars List of QNames that correspond to variables.  This list 
408    * should be searched backwards for the first qualified name that 
409    * corresponds to the variable reference qname.  The position of the 
410    * QName in the vector from the start of the vector will be its position 
411    * in the stack frame (but variables above the globalsTop value will need 
412    * to be offset to the current stack frame).
413    */
414   public void fixupVariables(java.util.Vector   vars, int globalsSize)
415   {
416     super.fixupVariables(vars, globalsSize);
417 
418     int nPredicates = getPredicateCount();
419 
420     for (int i = 0; i < nPredicates; i++)
421     {
422       m_predicates[i].fixupVariables(vars, globalsSize);
423     }
424   }
425 
426   
427   /**
428    * Diagnostics.
429    *
430    * @param n Node to give diagnostic information about, or null.
431    *
432    * @return Informative string about the argument.
433    */
434   protected String   nodeToString(int n)
435   {
436     if(DTM.NULL != n)
437     {
438       DTM dtm = m_lpi.getXPathContext().getDTM(n);
439       return dtm.getNodeName(n) + "{" + (n+1) + "}";
440     }
441     else
442     {
443       return "null";
444     }
445   }
446   
447   //=============== NodeFilter Implementation ===============
448 
449   /**
450    *  Test whether a specified node is visible in the logical view of a
451    * TreeWalker or NodeIterator. This function will be called by the
452    * implementation of TreeWalker and NodeIterator; it is not intended to
453    * be called directly from user code.
454    * @param n  The node to check to see if it passes the filter or not.
455    * @return  a constant to determine whether the node is accepted,
456    *   rejected, or skipped, as defined  above .
457    */
458   public short acceptNode(int n)
459   {
460 
461     XPathContext xctxt = m_lpi.getXPathContext();
462 
463     try
464     {
465       xctxt.pushCurrentNode(n);
466 
467       XObject score = execute(xctxt, n);
468 
469       // System.out.println("\n::acceptNode - score: "+score.num()+"::");
470       if (score != NodeTest.SCORE_NONE)
471       {
472         if (getPredicateCount() > 0)
473         {
474           countProximityPosition(0);
475 
476           if (!executePredicates(n, xctxt))
477             return DTMIterator.FILTER_SKIP;
478         }
479 
480         return DTMIterator.FILTER_ACCEPT;
481       }
482     }
483     catch (javax.xml.transform.TransformerException   se)
484     {
485 
486       // TODO: Fix this.
487       throw new RuntimeException  (se.getMessage());
488     }
489     finally
490     {
491       xctxt.popCurrentNode();
492     }
493 
494     return DTMIterator.FILTER_SKIP;
495   }
496 
497   
498   /**
499    * Get the owning location path iterator.
500    *
501    * @return the owning location path iterator, which should not be null.
502    */
503   public LocPathIterator getLocPathIterator()
504   {
505     return m_lpi;
506   }
507 
508   /**
509    * Set the location path iterator owner for this walker.  Besides 
510    * initialization, this function is called during cloning operations.
511    *
512    * @param li non-null reference to the owning location path iterator.
513    */
514   public void setLocPathIterator(LocPathIterator li)
515   {
516     m_lpi = li;
517     if(this != li)
518       li.exprSetParent(this);
519   }
520   
521   /**
522    * Tell if this expression or it's subexpressions can traverse outside 
523    * the current subtree.
524    * 
525    * @return true if traversal outside the context node's subtree can occur.
526    */
527    public boolean canTraverseOutsideSubtree()
528    {
529     int n = getPredicateCount();
530     for (int i = 0; i < n; i++) 
531     {
532       if(getPredicate(i).canTraverseOutsideSubtree())
533         return true;
534     }
535     return false;
536    }
537    
538     /**
539      * This will traverse the heararchy, calling the visitor for 
540      * each member.  If the called visitor method returns 
541      * false, the subtree should not be called.
542      * 
543      * @param owner The owner of the visitor, where that path may be 
544      *              rewritten if needed.
545      * @param visitor The visitor whose appropriate method will be called.
546      */
547     public void callPredicateVisitors(XPathVisitor visitor)
548     {
549       if (null != m_predicates)
550         {
551         int n = m_predicates.length;
552         for (int i = 0; i < n; i++)
553           {
554           ExpressionOwner predOwner = new PredOwner(i);
555           if (visitor.visitPredicate(predOwner, m_predicates[i]))
556             {
557             m_predicates[i].callVisitors(predOwner, visitor);
558           }
559     
560         }
561       }
562     } 
563     
564     /**
565      * @see Expression#deepEquals(Expression)
566      */
567     public boolean deepEquals(Expression expr)
568     {
569       if (!super.deepEquals(expr))
570             return false;
571 
572       PredicatedNodeTest pnt = (PredicatedNodeTest) expr;
573       if (null != m_predicates)
574       {
575 
576         int n = m_predicates.length;
577         if ((null == pnt.m_predicates) || (pnt.m_predicates.length != n))
578               return false;
579         for (int i = 0; i < n; i++)
580         {
581           if (!m_predicates[i].deepEquals(pnt.m_predicates[i]))
582             return false; 
583         }
584       }
585       else if (null != pnt.m_predicates)
586               return false; 
587               
588       return true; 
589     }
590     
591   /** This is true if nextNode returns null. */
592   transient protected boolean m_foundLast = false;
593     
594   /** The owning location path iterator.
595    *  @serial */
596   protected LocPathIterator m_lpi;
597   
598   /**
599    * Which predicate we are executing.
600    */
601   transient int m_predicateIndex = -1;
602   
603   /** The list of predicate expressions. Is static and does not need 
604    *  to be deep cloned.
605    *  @serial 
606    */
607   private Expression[] m_predicates;
608 
609   /**
610    * An array of counts that correspond to the number
611    * of predicates the step contains.
612    */
613   transient protected int[] m_proximityPositions;
614 
615   /** If true, diagnostic messages about predicate execution will be posted.  */
616   static final boolean DEBUG_PREDICATECOUNTING = false;
617   
618   class PredOwner implements ExpressionOwner
619   {
620     int m_index;
621     
622     PredOwner(int index)
623     {
624         m_index = index;
625     }
626     
627     /**
628      * @see ExpressionOwner#getExpression()
629      */
630     public Expression getExpression()
631     {
632       return m_predicates[m_index];
633     }
634 
635 
636     /**
637      * @see ExpressionOwner#setExpression(Expression)
638      */
639     public void setExpression(Expression exp)
640     {
641         exp.exprSetParent(PredicatedNodeTest.this);
642         m_predicates[m_index] = exp;
643     }
644   }
645     
646 }
647
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags