NodeSet


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: NodeSet.java,v 1.21 2004/02/17 04:30:02 minchau Exp $
18   */
19  package com.sun.org.apache.xpath.internal;
20  
21  import com.sun.org.apache.xalan.internal.res.XSLMessages;
22  import com.sun.org.apache.xml.internal.utils.DOM2Helper;
23  import com.sun.org.apache.xpath.internal.axes.ContextNodeList;
24  import com.sun.org.apache.xpath.internal.res.XPATHErrorResources;
25  
26  import org.w3c.dom.DOMException  ;
27  import org.w3c.dom.Node  ;
28  import org.w3c.dom.NodeList  ;
29  import org.w3c.dom.traversal.NodeFilter;
30  import org.w3c.dom.traversal.NodeIterator;
31  
32  
33  /**
34   * <p>The NodeSet class can act as either a NodeVector,
35   * NodeList, or NodeIterator.  However, in order for it to
36   * act as a NodeVector or NodeList, it's required that
37   * setShouldCacheNodes(true) be called before the first
38   * nextNode() is called, in order that nodes can be added
39   * as they are fetched.  Derived classes that implement iterators
40   * must override runTo(int index), in order that they may
41   * run the iteration to the given index. </p>
42   * 
43   * <p>Note that we directly implement the DOM's NodeIterator
44   * interface. We do not emulate all the behavior of the
45   * standard NodeIterator. In particular, we do not guarantee
46   * to present a "live view" of the document ... but in XSLT,
47   * the source document should never be mutated, so this should
48   * never be an issue.</p>
49   * 
50   * <p>Thought: Should NodeSet really implement NodeList and NodeIterator,
51   * or should there be specific subclasses of it which do so? The
52   * advantage of doing it all here is that all NodeSets will respond
53   * to the same calls; the disadvantage is that some of them may return
54   * less-than-enlightening results when you do so.</p>
55   * @xsl.usage advanced
56   */
57  public class NodeSet
58          implements NodeList, NodeIterator, Cloneable  , ContextNodeList
59  {
60  
61    /**
62     * Create an empty nodelist.
63     */
64    public NodeSet()
65    {
66      m_blocksize = 32;
67      m_mapSize = 0;
68    }
69  
70    /**
71     * Create an empty, using the given block size.
72     *
73     * @param blocksize Size of blocks to allocate 
74     */
75    public NodeSet(int blocksize)
76    {
77      m_blocksize = blocksize;
78      m_mapSize = 0;
79    }
80  
81    /**
82     * Create a NodeSet, and copy the members of the
83     * given nodelist into it.
84     *
85     * @param nodelist List of Nodes to be made members of the new set.
86     */
87    public NodeSet(NodeList nodelist)
88    {
89  
90      this(32);
91  
92      addNodes(nodelist);
93    }
94  
95    /**
96     * Create a NodeSet, and copy the members of the
97     * given NodeSet into it.
98     *
99     * @param nodelist Set of Nodes to be made members of the new set.
100    */
101   public NodeSet(NodeSet nodelist)
102   {
103 
104     this(32);
105 
106     addNodes((NodeIterator) nodelist);
107   }
108 
109   /**
110    * Create a NodeSet, and copy the members of the
111    * given NodeIterator into it.
112    *
113    * @param ni Iterator which yields Nodes to be made members of the new set.
114    */
115   public NodeSet(NodeIterator ni)
116   {
117 
118     this(32);
119 
120     addNodes(ni);
121   }
122 
123   /**
124    * Create a NodeSet which contains the given Node.
125    *
126    * @param node Single node to be added to the new set.
127    */
128   public NodeSet(Node   node)
129   {
130 
131     this(32);
132 
133     addNode(node);
134   }
135 
136   /**
137    * @return The root node of the Iterator, as specified when it was created.
138    * For non-Iterator NodeSets, this will be null.
139    */
140   public Node   getRoot()
141   {
142     return null;
143   }
144 
145   /**
146    * Get a cloned Iterator, and reset its state to the beginning of the
147    * iteration.
148    *
149    * @return a new NodeSet of the same type, having the same state...
150    * except that the reset() operation has been called.
151    *
152    * @throws CloneNotSupportedException if this subclass of NodeSet
153    * does not support the clone() operation.
154    */
155   public NodeIterator cloneWithReset() throws CloneNotSupportedException  
156   {
157 
158     NodeSet clone = (NodeSet) clone();
159 
160     clone.reset();
161 
162     return clone;
163   }
164 
165   /**
166    * Reset the iterator. May have no effect on non-iterator Nodesets.
167    */
168   public void reset()
169   {
170     m_next = 0;
171   }
172 
173   /**
174    *  This attribute determines which node types are presented via the
175    * iterator. The available set of constants is defined in the
176    * <code>NodeFilter</code> interface. For NodeSets, the mask has been
177    * hardcoded to show all nodes except EntityReference nodes, which have
178    * no equivalent in the XPath data model.
179    *
180    * @return integer used as a bit-array, containing flags defined in
181    * the DOM's NodeFilter class. The value will be 
182    * <code>SHOW_ALL & ~SHOW_ENTITY_REFERENCE</code>, meaning that
183    * only entity references are suppressed.
184    */
185   public int getWhatToShow()
186   {
187     return NodeFilter.SHOW_ALL & ~NodeFilter.SHOW_ENTITY_REFERENCE;
188   }
189 
190   /**
191    * The filter object used to screen nodes. Filters are applied to
192    * further reduce (and restructure) the NodeIterator's view of the
193    * document. In our case, we will be using hardcoded filters built
194    * into our iterators... but getFilter() is part of the DOM's 
195    * NodeIterator interface, so we have to support it.
196    *
197    * @return null, which is slightly misleading. True, there is no
198    * user-written filter object, but in fact we are doing some very
199    * sophisticated custom filtering. A DOM purist might suggest
200    * returning a placeholder object just to indicate that this is
201    * not going to return all nodes selected by whatToShow.
202    */
203   public NodeFilter getFilter()
204   {
205     return null;
206   }
207 
208   /**
209    *  The value of this flag determines whether the children of entity
210    * reference nodes are visible to the iterator. If false, they will be
211    * skipped over.
212    * <br> To produce a view of the document that has entity references
213    * expanded and does not expose the entity reference node itself, use the
214    * whatToShow flags to hide the entity reference node and set
215    * expandEntityReferences to true when creating the iterator. To produce
216    * a view of the document that has entity reference nodes but no entity
217    * expansion, use the whatToShow flags to show the entity reference node
218    * and set expandEntityReferences to false.
219    *
220    * @return true for all iterators based on NodeSet, meaning that the
221    * contents of EntityRefrence nodes may be returned (though whatToShow
222    * says that the EntityReferences themselves are not shown.)
223    */
224   public boolean getExpandEntityReferences()
225   {
226     return true;
227   }
228 
229   /**
230    *  Returns the next node in the set and advances the position of the
231    * iterator in the set. After a NodeIterator is created, the first call
232    * to nextNode() returns the first node in the set.
233    * @return  The next <code>Node</code> in the set being iterated over, or
234    *   <code>null</code> if there are no more members in that set.
235    * @throws DOMException
236    *    INVALID_STATE_ERR: Raised if this method is called after the
237    *   <code>detach</code> method was invoked.
238    */
239   public Node   nextNode() throws DOMException  
240   {
241 
242     if ((m_next) < this.size())
243     {
244       Node   next = this.elementAt(m_next);
245 
246       m_next++;
247 
248       return next;
249     }
250     else
251       return null;
252   }
253 
254   /**
255    *  Returns the previous node in the set and moves the position of the
256    * iterator backwards in the set.
257    * @return  The previous <code>Node</code> in the set being iterated over,
258    *   or<code>null</code> if there are no more members in that set.
259    * @throws DOMException
260    *    INVALID_STATE_ERR: Raised if this method is called after the
261    *   <code>detach</code> method was invoked.
262    * @throws RuntimeException thrown if this NodeSet is not of 
263    * a cached type, and hence doesn't know what the previous node was.
264    */
265   public Node   previousNode() throws DOMException  
266   {
267 
268     if (!m_cacheNodes)
269       throw new RuntimeException  (
270         XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_CANNOT_ITERATE, null)); //"This NodeSet can not iterate to a previous node!");
271 
272     if ((m_next - 1) > 0)
273     {
274       m_next--;
275 
276       return this.elementAt(m_next);
277     }
278     else
279       return null;
280   }
281 
282   /**
283    * Detaches the iterator from the set which it iterated over, releasing
284    * any computational resources and placing the iterator in the INVALID
285    * state. After<code>detach</code> has been invoked, calls to
286    * <code>nextNode</code> or<code>previousNode</code> will raise the
287    * exception INVALID_STATE_ERR.
288    * <p>
289    * This operation is a no-op in NodeSet, and will not cause 
290    * INVALID_STATE_ERR to be raised by later operations.
291    * </p>
292    */
293   public void detach(){}
294 
295   /**
296    * Tells if this NodeSet is "fresh", in other words, if
297    * the first nextNode() that is called will return the
298    * first node in the set.
299    *
300    * @return true if nextNode() would return the first node in the set,
301    * false if it would return a later one.
302    */
303   public boolean isFresh()
304   {
305     return (m_next == 0);
306   }
307 
308   /**
309    * If an index is requested, NodeSet will call this method
310    * to run the iterator to the index.  By default this sets
311    * m_next to the index.  If the index argument is -1, this
312    * signals that the iterator should be run to the end.
313    *
314    * @param index Position to advance (or retreat) to, with
315    * 0 requesting the reset ("fresh") position and -1 (or indeed
316    * any out-of-bounds value) requesting the final position.
317    * @throws RuntimeException thrown if this NodeSet is not
318    * one of the types which supports indexing/counting.
319    */
320   public void runTo(int index)
321   {
322 
323     if (!m_cacheNodes)
324       throw new RuntimeException  (
325         XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_CANNOT_INDEX, null)); //"This NodeSet can not do indexing or counting functions!");
326 
327     if ((index >= 0) && (m_next < m_firstFree))
328       m_next = index;
329     else
330       m_next = m_firstFree - 1;
331   }
332 
333   /**
334    * Returns the <code>index</code>th item in the collection. If
335    * <code>index</code> is greater than or equal to the number of nodes in
336    * the list, this returns <code>null</code>.
337    * 
338    * TODO: What happens if index is out of range?
339    * 
340    * @param index Index into the collection.
341    * @return The node at the <code>index</code>th position in the
342    *   <code>NodeList</code>, or <code>null</code> if that is not a valid
343    *   index.
344    */
345   public Node   item(int index)
346   {
347 
348     runTo(index);
349 
350     return (Node  ) this.elementAt(index);
351   }
352 
353   /**
354    * The number of nodes in the list. The range of valid child node indices is
355    * 0 to <code>length-1</code> inclusive. Note that this operation requires
356    * finding all the matching nodes, which may defeat attempts to defer
357    * that work.
358    *
359    * @return integer indicating how many nodes are represented by this list.
360    */
361   public int getLength()
362   {
363 
364     runTo(-1);
365 
366     return this.size();
367   }
368 
369   /**
370    * Add a node to the NodeSet. Not all types of NodeSets support this
371    * operation
372    *
373    * @param n Node to be added
374    * @throws RuntimeException thrown if this NodeSet is not of 
375    * a mutable type.
376    */
377   public void addNode(Node   n)
378   {
379 
380     if (!m_mutable)
381       throw new RuntimeException  (XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");
382 
383     this.addElement(n);
384   }
385 
386   /**
387    * Insert a node at a given position.
388    *
389    * @param n Node to be added
390    * @param pos Offset at which the node is to be inserted,
391    * with 0 being the first position.
392    * @throws RuntimeException thrown if this NodeSet is not of 
393    * a mutable type.
394    */
395   public void insertNode(Node   n, int pos)
396   {
397 
398     if (!m_mutable)
399       throw new RuntimeException  (XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");
400 
401     insertElementAt(n, pos);
402   }
403 
404   /**
405    * Remove a node.
406    *
407    * @param n Node to be added
408    * @throws RuntimeException thrown if this NodeSet is not of 
409    * a mutable type.
410    */
411   public void removeNode(Node   n)
412   {
413 
414     if (!m_mutable)
415       throw new RuntimeException  (XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");
416 
417     this.removeElement(n);
418   }
419 
420   /**
421    * Copy NodeList members into this nodelist, adding in
422    * document order.  If a node is null, don't add it.
423    *
424    * @param nodelist List of nodes which should now be referenced by
425    * this NodeSet.
426    * @throws RuntimeException thrown if this NodeSet is not of 
427    * a mutable type.
428    */
429   public void addNodes(NodeList nodelist)
430   {
431 
432     if (!m_mutable)
433       throw new RuntimeException  (XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");
434 
435     if (null != nodelist)  // defensive to fix a bug that Sanjiva reported.
436     {
437       int nChildren = nodelist.getLength();
438 
439       for (int i = 0; i < nChildren; i++)
440       {
441         Node   obj = nodelist.item(i);
442 
443         if (null != obj)
444         {
445           addElement(obj);
446         }
447       }
448     }
449 
450     // checkDups();
451   }
452 
453   /**
454    * <p>Copy NodeList members into this nodelist, adding in
455    * document order.  Only genuine node references will be copied;
456    * nulls appearing in the source NodeSet will
457    * not be added to this one. </p>
458    * 
459    * <p> In case you're wondering why this function is needed: NodeSet
460    * implements both NodeIterator and NodeList. If this method isn't
461    * provided, Java can't decide which of those to use when addNodes()
462    * is invoked. Providing the more-explicit match avoids that
463    * ambiguity.)</p>
464    *
465    * @param ns NodeSet whose members should be merged into this NodeSet.
466    * @throws RuntimeException thrown if this NodeSet is not of 
467    * a mutable type.
468    */
469   public void addNodes(NodeSet ns)
470   {
471 
472     if (!m_mutable)
473       throw new RuntimeException  (XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");
474 
475     addNodes((NodeIterator) ns);
476   }
477 
478   /**
479    * Copy NodeList members into this nodelist, adding in
480    * document order.  Null references are not added.
481    *
482    * @param iterator NodeIterator which yields the nodes to be added.
483    * @throws RuntimeException thrown if this NodeSet is not of 
484    * a mutable type.
485    */
486   public void addNodes(NodeIterator iterator)
487   {
488 
489     if (!m_mutable)
490       throw new RuntimeException  (XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");
491 
492     if (null != iterator)  // defensive to fix a bug that Sanjiva reported.
493     {
494       Node   obj;
495 
496       while (null != (obj = iterator.nextNode()))
497       {
498         addElement(obj);
499       }
500     }
501 
502     // checkDups();
503   }
504 
505   /**
506    * Copy NodeList members into this nodelist, adding in
507    * document order.  If a node is null, don't add it.
508    *
509    * @param nodelist List of nodes to be added
510    * @param support The XPath runtime context.
511    * @throws RuntimeException thrown if this NodeSet is not of 
512    * a mutable type.
513    */
514   public void addNodesInDocOrder(NodeList nodelist, XPathContext support)
515   {
516 
517     if (!m_mutable)
518       throw new RuntimeException  (XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");
519 
520     int nChildren = nodelist.getLength();
521 
522     for (int i = 0; i < nChildren; i++)
523     {
524       Node   node = nodelist.item(i);
525 
526       if (null != node)
527       {
528         addNodeInDocOrder(node, support);
529       }
530     }
531   }
532 
533   /**
534    * Copy NodeList members into this nodelist, adding in
535    * document order.  If a node is null, don't add it.
536    *
537    * @param iterator NodeIterator which yields the nodes to be added.
538    * @param support The XPath runtime context.
539    * @throws RuntimeException thrown if this NodeSet is not of 
540    * a mutable type.
541    */
542   public void addNodesInDocOrder(NodeIterator iterator, XPathContext support)
543   {
544 
545     if (!m_mutable)
546       throw new RuntimeException  (XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");
547 
548     Node   node;
549 
550     while (null != (node = iterator.nextNode()))
551     {
552       addNodeInDocOrder(node, support);
553     }
554   }
555 
556   /**
557    * Add the node list to this node set in document order.
558    *
559    * @param start index.
560    * @param end index.
561    * @param testIndex index.
562    * @param nodelist The nodelist to add.
563    * @param support The XPath runtime context.
564    *
565    * @return false always.
566    * @throws RuntimeException thrown if this NodeSet is not of 
567    * a mutable type.
568    */
569   private boolean addNodesInDocOrder(int start, int end, int testIndex,
570                                      NodeList nodelist, XPathContext support)
571   {
572 
573     if (!m_mutable)
574       throw new RuntimeException  (XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");
575 
576     boolean foundit = false;
577     int i;
578     Node   node = nodelist.item(testIndex);
579 
580     for (i = end; i >= start; i--)
581     {
582       Node   child = (Node  ) elementAt(i);
583 
584       if (child == node)
585       {
586         i = -2;  // Duplicate, suppress insert
587 
588         break;
589       }
590 
591       if (!DOM2Helper.isNodeAfter(node, child))
592       {
593         insertElementAt(node, i + 1);
594 
595         testIndex--;
596 
597         if (testIndex > 0)
598         {
599           boolean foundPrev = addNodesInDocOrder(0, i, testIndex, nodelist,
600                                                  support);
601 
602           if (!foundPrev)
603           {
604             addNodesInDocOrder(i, size() - 1, testIndex, nodelist, support);
605           }
606         }
607 
608         break;
609       }
610     }
611 
612     if (i == -1)
613     {
614       insertElementAt(node, 0);
615     }
616 
617     return foundit;
618   }
619 
620   /**
621    * Add the node into a vector of nodes where it should occur in
622    * document order.
623    * @param v Vector of nodes, presumably containing Nodes
624    * @param obj Node object.
625    *
626    * @param node The node to be added.
627    * @param test true if we should test for doc order
628    * @param support The XPath runtime context.
629    * @return insertIndex.
630    * @throws RuntimeException thrown if this NodeSet is not of 
631    * a mutable type.
632    */
633   public int addNodeInDocOrder(Node   node, boolean test, XPathContext support)
634   {
635 
636     if (!m_mutable)
637       throw new RuntimeException  (XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");
638 
639     int insertIndex = -1;
640 
641     if (test)
642     {
643 
644       // This needs to do a binary search, but a binary search 
645       // is somewhat tough because the sequence test involves 
646       // two nodes.
647       int size = size(), i;
648 
649       for (i = size - 1; i >= 0; i--)
650       {
651         Node   child = (Node  ) elementAt(i);
652 
653         if (child == node)
654         {
655           i = -2;  // Duplicate, suppress insert
656 
657           break;
658         }
659 
660         if (!DOM2Helper.isNodeAfter(node, child))
661         {
662           break;
663         }
664       }
665 
666       if (i != -2)
667       {
668         insertIndex = i + 1;
669 
670         insertElementAt(node, insertIndex);
671       }
672     }
673     else
674     {
675       insertIndex = this.size();
676 
677       boolean foundit = false;
678 
679       for (int i = 0; i < insertIndex; i++)
680       {
681         if (this.item(i).equals(node))
682         {
683           foundit = true;
684 
685           break;
686         }
687       }
688 
689       if (!foundit)
690         addElement(node);
691     }
692 
693     // checkDups();
694     return insertIndex;
695   }  // end addNodeInDocOrder(Vector v, Object obj)
696 
697   /**
698    * Add the node into a vector of nodes where it should occur in
699    * document order.
700    * @param v Vector of nodes, presumably containing Nodes
701    * @param obj Node object.
702    *
703    * @param node The node to be added.
704    * @param support The XPath runtime context.
705    *
706    * @return The index where it was inserted.
707    * @throws RuntimeException thrown if this NodeSet is not of 
708    * a mutable type.
709    */
710   public int addNodeInDocOrder(Node   node, XPathContext support)
711   {
712 
713     if (!m_mutable)
714       throw new RuntimeException  (XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");
715 
716     return addNodeInDocOrder(node, true, support);
717   }  // end addNodeInDocOrder(Vector v, Object obj)
718 
719 
720   /** If this node is being used as an iterator, the next index that nextNode()
721    *  will return.  */
722   transient protected int m_next = 0;
723 
724   /**
725    * Get the current position, which is one less than
726    * the next nextNode() call will retrieve.  i.e. if
727    * you call getCurrentPos() and the return is 0, the next
728    * fetch will take place at index 1.
729    *
730    * @return The the current position index.
731    */
732   public int getCurrentPos()
733   {
734     return m_next;
735   }
736 
737   /**
738    * Set the current position in the node set.
739    * @param i Must be a valid index.
740    * @throws RuntimeException thrown if this NodeSet is not of 
741    * a cached type, and thus doesn't permit indexed access.
742    */
743   public void setCurrentPos(int i)
744   {
745 
746     if (!m_cacheNodes)
747       throw new RuntimeException  (
748         XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_CANNOT_INDEX, null)); //"This NodeSet can not do indexing or counting functions!");
749 
750     m_next = i;
751   }
752 
753   /**
754    * Return the last fetched node.  Needed to support the UnionPathIterator.
755    *
756    * @return the last fetched node.
757    * @throws RuntimeException thrown if this NodeSet is not of 
758    * a cached type, and thus doesn't permit indexed access.
759    */
760   public Node   getCurrentNode()
761   {
762 
763     if (!m_cacheNodes)
764       throw new RuntimeException  (
765         XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_CANNOT_INDEX, null)); //"This NodeSet can not do indexing or counting functions!");
766 
767     int saved = m_next;
768     Node   n = (m_next < m_firstFree) ? elementAt(m_next) : null;
769     m_next = saved; // HACK: I think this is a bit of a hack.  -sb
770     return n;
771   }
772 
773   /** True if this list can be mutated.  */
774   transient protected boolean m_mutable = true;
775 
776   /** True if this list is cached.
777    *  @serial  */
778   transient protected boolean m_cacheNodes = true;
779 
780   /**
781    * Get whether or not this is a cached node set.
782    *
783    *
784    * @return True if this list is cached.
785    */
786   public boolean getShouldCacheNodes()
787   {
788     return m_cacheNodes;
789   }
790 
791   /**
792    * If setShouldCacheNodes(true) is called, then nodes will
793    * be cached.  They are not cached by default. This switch must
794    * be set before the first call to nextNode is made, to ensure
795    * that all nodes are cached.
796    *
797    * @param b true if this node set should be cached.
798    * @throws RuntimeException thrown if an attempt is made to
799    * request caching after we've already begun stepping through the
800    * nodes in this set.
801   */
802   public void setShouldCacheNodes(boolean b)
803   {
804 
805     if (!isFresh())
806       throw new RuntimeException  (
807         XSLMessages.createXPATHMessage(XPATHErrorResources.ER_CANNOT_CALL_SETSHOULDCACHENODE, null)); //"Can not call setShouldCacheNodes after nextNode has been called!");
808 
809     m_cacheNodes = b;
810     m_mutable = true;
811   }
812   
813   
814   transient private int m_last = 0;
815   
816   public int getLast()
817   {
818     return m_last;
819   }
820   
821   public void setLast(int last)
822   {
823     m_last = last;
824   }
825   
826   /** Size of blocks to allocate.
827    *  @serial          */
828   private int m_blocksize;
829 
830   /** Array of nodes this points to.
831    *  @serial          */
832   Node   m_map[];
833 
834   /** Number of nodes in this NodeVector.
835    *  @serial          */
836   protected int m_firstFree = 0;
837 
838   /** Size of the array this points to.
839    *  @serial           */
840   private int m_mapSize;  // lazy initialization
841 
842   /**
843    * Get a cloned LocPathIterator.
844    *
845    * @return A clone of this
846    *
847    * @throws CloneNotSupportedException
848    */
849   public Object   clone() throws CloneNotSupportedException  
850   {
851 
852     NodeSet clone = (NodeSet) super.clone();
853 
854     if ((null != this.m_map) && (this.m_map == clone.m_map))
855     {
856       clone.m_map = new Node  [this.m_map.length];
857 
858       System.arraycopy(this.m_map, 0, clone.m_map, 0, this.m_map.length);
859     }
860 
861     return clone;
862   }
863 
864   /**
865    * Get the length of the list.
866    *
867    * @return Number of nodes in this NodeVector
868    */
869   public int size()
870   {
871     return m_firstFree;
872   }
873 
874   /**
875    * Append a Node onto the vector.
876    *
877    * @param value Node to add to the vector
878    */
879   public void addElement(Node   value)
880   {
881     if (!m_mutable)
882       throw new RuntimeException  (XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");
883 
884     if ((m_firstFree + 1) >= m_mapSize)
885     {
886       if (null == m_map)
887       {
888         m_map = new Node  [m_blocksize];
889         m_mapSize = m_blocksize;
890       }
891       else
892       {
893         m_mapSize += m_blocksize;
894 
895         Node   newMap[] = new Node  [m_mapSize];
896 
897         System.arraycopy(m_map, 0, newMap, 0, m_firstFree + 1);
898 
899         m_map = newMap;
900       }
901     }
902 
903     m_map[m_firstFree] = value;
904 
905     m_firstFree++;
906   }
907 
908   /**
909    * Append a Node onto the vector.
910    *
911    * @param value Node to add to the vector
912    */
913   public final void push(Node   value)
914   {
915 
916     int ff = m_firstFree;
917 
918     if ((ff + 1) >= m_mapSize)
919     {
920       if (null == m_map)
921       {
922         m_map = new Node  [m_blocksize];
923         m_mapSize = m_blocksize;
924       }
925       else
926       {
927         m_mapSize += m_blocksize;
928 
929         Node   newMap[] = new Node  [m_mapSize];
930 
931         System.arraycopy(m_map, 0, newMap, 0, ff + 1);
932 
933         m_map = newMap;
934       }
935     }
936 
937     m_map[ff] = value;
938 
939     ff++;
940 
941     m_firstFree = ff;
942   }
943 
944   /**
945    * Pop a node from the tail of the vector and return the result.
946    *
947    * @return the node at the tail of the vector
948    */
949   public final Node   pop()
950   {
951 
952     m_firstFree--;
953 
954     Node   n = m_map[m_firstFree];
955 
956     m_map[m_firstFree] = null;
957 
958     return n;
959   }
960 
961   /**
962    * Pop a node from the tail of the vector and return the
963    * top of the stack after the pop.
964    *
965    * @return The top of the stack after it's been popped 
966    */
967   public final Node   popAndTop()
968   {
969 
970     m_firstFree--;
971 
972     m_map[m_firstFree] = null;
973 
974     return (m_firstFree == 0) ? null : m_map[m_firstFree - 1];
975   }
976 
977   /**
978    * Pop a node from the tail of the vector.
979    */
980   public final void popQuick()
981   {
982 
983     m_firstFree--;
984 
985     m_map[m_firstFree] = null;
986   }
987 
988   /**
989    * Return the node at the top of the stack without popping the stack.
990    * Special purpose method for TransformerImpl, pushElemTemplateElement.
991    * Performance critical.
992    *
993    * @return Node at the top of the stack or null if stack is empty.  
994    */
995   public final Node   peepOrNull()
996   {
997     return ((null != m_map) && (m_firstFree > 0))
998            ? m_map[m_firstFree - 1] : null;
999   }
1000
1001  /**
1002   * Push a pair of nodes into the stack.  
1003   * Special purpose method for TransformerImpl, pushElemTemplateElement.
1004   * Performance critical.
1005   *
1006   * @param v1 First node to add to vector
1007   * @param v2 Second node to add to vector
1008   */
1009  public final void pushPair(Node   v1, Node   v2)
1010  {
1011
1012    if (null == m_map)
1013    {
1014      m_map = new Node  [m_blocksize];
1015      m_mapSize = m_blocksize;
1016    }
1017    else
1018    {
1019      if ((m_firstFree + 2) >= m_mapSize)
1020      {
1021        m_mapSize += m_blocksize;
1022
1023        Node   newMap[] = new Node  [m_mapSize];
1024
1025        System.arraycopy(m_map, 0, newMap, 0, m_firstFree);
1026
1027        m_map = newMap;
1028      }
1029    }
1030
1031    m_map[m_firstFree] = v1;
1032    m_map[m_firstFree + 1] = v2;
1033    m_firstFree += 2;
1034  }
1035
1036  /**
1037   * Pop a pair of nodes from the tail of the stack. 
1038   * Special purpose method for TransformerImpl, pushElemTemplateElement.
1039   * Performance critical.
1040   */
1041  public final void popPair()
1042  {
1043
1044    m_firstFree -= 2;
1045    m_map[m_firstFree] = null;
1046    m_map[m_firstFree + 1] = null;
1047  }
1048
1049  /**
1050   * Set the tail of the stack to the given node.
1051   * Special purpose method for TransformerImpl, pushElemTemplateElement.
1052   * Performance critical.
1053   *
1054   * @param n Node to set at the tail of vector
1055   */
1056  public final void setTail(Node   n)
1057  {
1058    m_map[m_firstFree - 1] = n;
1059  }
1060
1061  /**
1062   * Set the given node one position from the tail.
1063   * Special purpose method for TransformerImpl, pushElemTemplateElement.
1064   * Performance critical.
1065   *
1066   * @param n Node to set
1067   */
1068  public final void setTailSub1(Node   n)
1069  {
1070    m_map[m_firstFree - 2] = n;
1071  }
1072
1073  /**
1074   * Return the node at the tail of the vector without popping
1075   * Special purpose method for TransformerImpl, pushElemTemplateElement.
1076   * Performance critical.
1077   *
1078   * @return Node at the tail of the vector
1079   */
1080  public final Node   peepTail()
1081  {
1082    return m_map[m_firstFree - 1];
1083  }
1084
1085  /**
1086   * Return the node one position from the tail without popping.
1087   * Special purpose method for TransformerImpl, pushElemTemplateElement.
1088   * Performance critical.
1089   *
1090   * @return Node one away from the tail
1091   */
1092  public final Node   peepTailSub1()
1093  {
1094    return m_map[m_firstFree - 2];
1095  }
1096
1097  /**
1098   * Inserts the specified node in this vector at the specified index.
1099   * Each component in this vector with an index greater or equal to
1100   * the specified index is shifted upward to have an index one greater
1101   * than the value it had previously.
1102   *
1103   * @param value Node to insert
1104   * @param at Position where to insert
1105   */
1106  public void insertElementAt(Node   value, int at)
1107  {
1108    if (!m_mutable)
1109      throw new RuntimeException  (XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");
1110
1111    if (null == m_map)
1112    {
1113      m_map = new Node  [m_blocksize];
1114      m_mapSize = m_blocksize;
1115    }
1116    else if ((m_firstFree + 1) >= m_mapSize)
1117    {
1118      m_mapSize += m_blocksize;
1119
1120      Node   newMap[] = new Node  [m_mapSize];
1121
1122      System.arraycopy(m_map, 0, newMap, 0, m_firstFree + 1);
1123
1124      m_map = newMap;
1125    }
1126
1127    if (at <= (m_firstFree - 1))
1128    {
1129      System.arraycopy(m_map, at, m_map, at + 1, m_firstFree - at);
1130    }
1131
1132    m_map[at] = value;
1133
1134    m_firstFree++;
1135  }
1136
1137  /**
1138   * Append the nodes to the list.
1139   *
1140   * @param nodes NodeVector to append to this list
1141   */
1142  public void appendNodes(NodeSet nodes)
1143  {
1144
1145    int nNodes = nodes.size();
1146
1147    if (null == m_map)
1148    {
1149      m_mapSize = nNodes + m_blocksize;
1150      m_map = new Node  [m_mapSize];
1151    }
1152    else if ((m_firstFree + nNodes) >= m_mapSize)
1153    {
1154      m_mapSize += (nNodes + m_blocksize);
1155
1156      Node   newMap[] = new Node  [m_mapSize];
1157
1158      System.arraycopy(m_map, 0, newMap, 0, m_firstFree + nNodes);
1159
1160      m_map = newMap;
1161    }
1162
1163    System.arraycopy(nodes.m_map, 0, m_map, m_firstFree, nNodes);
1164
1165    m_firstFree += nNodes;
1166  }
1167
1168  /**
1169   * Inserts the specified node in this vector at the specified index.
1170   * Each component in this vector with an index greater or equal to
1171   * the specified index is shifted upward to have an index one greater
1172   * than the value it had previously.
1173   */
1174  public void removeAllElements()
1175  {
1176
1177    if (null == m_map)
1178      return;
1179
1180    for (int i = 0; i < m_firstFree; i++)
1181    {
1182      m_map[i] = null;
1183    }
1184
1185    m_firstFree = 0;
1186  }
1187
1188  /**
1189   * Removes the first occurrence of the argument from this vector.
1190   * If the object is found in this vector, each component in the vector
1191   * with an index greater or equal to the object's index is shifted
1192   * downward to have an index one smaller than the value it had
1193   * previously.
1194   *
1195   * @param s Node to remove from the list
1196   *
1197   * @return True if the node was successfully removed
1198   */
1199  public boolean removeElement(Node   s)
1200  {
1201    if (!m_mutable)
1202      throw new RuntimeException  (XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");
1203
1204    if (null == m_map)
1205      return false;
1206
1207    for (int i = 0; i < m_firstFree; i++)
1208    {
1209      Node   node = m_map[i];
1210
1211      if ((null != node) && node.equals(s))
1212      {
1213        if (i < m_firstFree - 1)
1214          System.arraycopy(m_map, i + 1, m_map, i, m_firstFree - i - 1);
1215
1216        m_firstFree--;
1217        m_map[m_firstFree] = null;
1218
1219        return true;
1220      }
1221    }
1222
1223    return false;
1224  }
1225
1226  /**
1227   * Deletes the component at the specified index. Each component in
1228   * this vector with an index greater or equal to the specified
1229   * index is shifted downward to have an index one smaller than
1230   * the value it had previously.
1231   *
1232   * @param i Index of node to remove
1233   */
1234  public void removeElementAt(int i)
1235  {
1236
1237    if (null == m_map)
1238      return;
1239      
1240    if (i >= m_firstFree)
1241      throw new ArrayIndexOutOfBoundsException  (i + " >= " + m_firstFree);
1242    else if (i < 0)
1243      throw new ArrayIndexOutOfBoundsException  (i);
1244
1245    if (i < m_firstFree - 1)
1246      System.arraycopy(m_map, i + 1, m_map, i, m_firstFree - i - 1);
1247
1248    m_firstFree--;
1249    m_map[m_firstFree] = null;
1250  }
1251
1252  /**
1253   * Sets the component at the specified index of this vector to be the
1254   * specified object. The previous component at that position is discarded.
1255   *
1256   * The index must be a value greater than or equal to 0 and less
1257   * than the current size of the vector.
1258   *
1259   * @param node Node to set
1260   * @param index Index of where to set the node
1261   */
1262  public void setElementAt(Node   node, int index)
1263  {
1264    if (!m_mutable)
1265      throw new RuntimeException  (XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");
1266
1267    if (null == m_map)
1268    {
1269      m_map = new Node  [m_blocksize];
1270      m_mapSize = m_blocksize;
1271    }
1272
1273    m_map[index] = node;
1274  }
1275
1276  /**
1277   * Get the nth element.
1278   *
1279   * @param i Index of node to get
1280   *
1281   * @return Node at specified index
1282   */
1283  public Node   elementAt(int i)
1284  {
1285
1286    if (null == m_map)
1287      return null;
1288
1289    return m_map[i];
1290  }
1291
1292  /**
1293   * Tell if the table contains the given node.
1294   *
1295   * @param s Node to look for
1296   *
1297   * @return True if the given node was found.
1298   */
1299  public boolean contains(Node   s)
1300  {
1301    runTo(-1);
1302
1303    if (null == m_map)
1304      return false;
1305
1306    for (int i = 0; i < m_firstFree; i++)
1307    {
1308      Node   node = m_map[i];
1309
1310      if ((null != node) && node.equals(s))
1311        return true;
1312    }
1313
1314    return false;
1315  }
1316
1317  /**
1318   * Searches for the first occurence of the given argument,
1319   * beginning the search at index, and testing for equality
1320   * using the equals method.
1321   *
1322   * @param elem Node to look for
1323   * @param index Index of where to start the search
1324   * @return the index of the first occurrence of the object
1325   * argument in this vector at position index or later in the
1326   * vector; returns -1 if the object is not found.
1327   */
1328  public int indexOf(Node   elem, int index)
1329  {
1330    runTo(-1);
1331
1332    if (null == m_map)
1333      return -1;
1334
1335    for (int i = index; i < m_firstFree; i++)
1336    {
1337      Node   node = m_map[i];
1338
1339      if ((null != node) && node.equals(elem))
1340        return i;
1341    }
1342
1343    return -1;
1344  }
1345
1346  /**
1347   * Searches for the first occurence of the given argument,
1348   * beginning the search at index, and testing for equality
1349   * using the equals method.
1350   *
1351   * @param elem Node to look for 
1352   * @return the index of the first occurrence of the object
1353   * argument in this vector at position index or later in the
1354   * vector; returns -1 if the object is not found.
1355   */
1356  public int indexOf(Node   elem)
1357  {
1358    runTo(-1);
1359
1360    if (null == m_map)
1361      return -1;
1362
1363    for (int i = 0; i < m_firstFree; i++)
1364    {
1365      Node   node = m_map[i];
1366
1367      if ((null != node) && node.equals(elem))
1368        return i;
1369    }
1370
1371    return -1;
1372  }
1373
1374}
1375
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags