SimpleResultTreeImpl


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: SimpleResultTreeImpl.java,v 1.7 2004/02/16 22:54:59 minchau Exp $
18   */
19  package com.sun.org.apache.xalan.internal.xsltc.dom;
20  
21  import com.sun.org.apache.xalan.internal.xsltc.DOM;
22  import com.sun.org.apache.xalan.internal.xsltc.TransletException;
23  import com.sun.org.apache.xalan.internal.xsltc.StripFilter;
24  import com.sun.org.apache.xalan.internal.xsltc.runtime.Hashtable;
25  
26  import com.sun.org.apache.xml.internal.dtm.DTM;
27  import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
28  import com.sun.org.apache.xml.internal.dtm.DTMAxisTraverser;
29  import com.sun.org.apache.xml.internal.dtm.DTMManager;
30  import com.sun.org.apache.xml.internal.dtm.ref.DTMAxisIteratorBase;
31  import com.sun.org.apache.xml.internal.dtm.ref.DTMManagerDefault;
32  import com.sun.org.apache.xml.internal.serializer.EmptySerializer;
33  import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
34  import com.sun.org.apache.xml.internal.utils.XMLString;
35  import com.sun.org.apache.xml.internal.utils.XMLStringDefault;
36  
37  import org.w3c.dom.Node  ;
38  import org.w3c.dom.NodeList  ;
39  
40  import org.xml.sax.SAXException  ;
41  
42  import javax.xml.transform.SourceLocator  ;
43  
44  /**
45   * This class represents a light-weight DOM model for simple result tree fragment(RTF).
46   * A simple RTF is an RTF that has only one Text node. The Text node can be produced by a
47   * combination of Text, xsl:value-of and xsl:number instructions. It can also be produced
48   * by a control structure (xsl:if or xsl:choose) whose body is pure Text.
49   * <p>
50   * A SimpleResultTreeImpl has only two nodes, i.e. the ROOT node and its Text child. All DOM
51   * interfaces are overridden with this in mind. For example, the getStringValue() interface
52   * returns the value of the Text node. This class receives the character data from the 
53   * characters() interface.
54   * <p>
55   * This class implements DOM and SerializationHandler. It also implements the DTM interface
56   * for support in MultiDOM. The nested iterators (SimpleIterator and SingletonIterator) are
57   * used to support the nodeset() extension function.
58   */
59  public class SimpleResultTreeImpl extends EmptySerializer implements DOM, DTM
60  {
61      
62      /**
63       * The SimpleIterator is designed to support the nodeset() extension function. It has
64       * a traversal direction parameter. The DOWN direction is used for child and descendant
65       * axes, while the UP direction is used for parent and ancestor axes.
66       *
67       * This iterator only handles two nodes (RTF_ROOT and RTF_TEXT). If the type is set,
68       * it will also match the node type with the given type.
69       */
70      public final class SimpleIterator extends DTMAxisIteratorBase
71      {
72          static final int DIRECTION_UP = 0;
73          static final int DIRECTION_DOWN = 1;
74          static final int NO_TYPE = -1;
75          
76          // The direction of traversal (default to DOWN).
77          // DOWN is for child and descendant. UP is for parent and ancestor.
78          int _direction = DIRECTION_DOWN;
79          
80          int _type = NO_TYPE;
81          int _currentNode;
82          
83          public SimpleIterator()
84          {
85          }
86          
87          public SimpleIterator(int direction)
88          {
89              _direction = direction;
90          }
91          
92          public SimpleIterator(int direction, int type)
93          {
94               _direction = direction;
95               _type = type;
96          }
97          
98          public int next()
99          {
100             // Increase the node ID for down traversal. Also match the node type
101             // if the type is given.
102             if (_direction == DIRECTION_DOWN) {                
103                 while (_currentNode < NUMBER_OF_NODES) {
104                     if (_type != NO_TYPE) {
105                         if ((_currentNode == RTF_ROOT && _type == DTM.ROOT_NODE)
106                             || (_currentNode == RTF_TEXT && _type == DTM.TEXT_NODE))
107                             return returnNode(getNodeHandle(_currentNode++));
108                         else
109                             _currentNode++;
110                     }
111                     else
112                         return returnNode(getNodeHandle(_currentNode++));
113                 }
114                 
115                 return END;
116             }
117             // Decrease the node ID for up traversal.
118             else {                
119                 while (_currentNode >= 0) {
120                     if (_type != NO_TYPE) {
121                         if ((_currentNode == RTF_ROOT && _type == DTM.ROOT_NODE)
122                             || (_currentNode == RTF_TEXT && _type == DTM.TEXT_NODE))
123                             return returnNode(getNodeHandle(_currentNode--));
124                         else
125                             _currentNode--;
126                     }
127                     else
128                         return returnNode(getNodeHandle(_currentNode--));
129                 }
130                 
131                 return END;
132             }
133         }
134                 
135         public DTMAxisIterator setStartNode(int nodeHandle)
136         {
137             int nodeID = getNodeIdent(nodeHandle);
138             _startNode = nodeID;
139             
140             // Increase the node ID by 1 if self is not included.
141             if (!_includeSelf && nodeID != DTM.NULL) {
142                 if (_direction == DIRECTION_DOWN)
143                     nodeID++;
144                 else if (_direction == DIRECTION_UP)
145                     nodeID--;
146             }
147             
148             _currentNode = nodeID;
149             return this;
150         }
151                 
152         public void setMark()
153         {
154             _markedNode = _currentNode;
155         }
156         
157         public void gotoMark()
158         {
159             _currentNode = _markedNode;
160         }
161         
162     } // END of SimpleIterator
163     
164     /**
165      * The SingletonIterator is used for the self axis.
166      */
167     public final class SingletonIterator extends DTMAxisIteratorBase
168     {
169         static final int NO_TYPE = -1;
170         int _type = NO_TYPE;
171         int _currentNode;
172         
173         public SingletonIterator()
174         {
175         }
176         
177         public SingletonIterator(int type)
178         {
179             _type = type;
180         }
181         
182         public void setMark()
183         {
184             _markedNode = _currentNode;
185         }
186         
187         public void gotoMark()
188         {
189             _currentNode = _markedNode;
190         }
191 
192         public DTMAxisIterator setStartNode(int nodeHandle)
193         {
194             _currentNode = _startNode = getNodeIdent(nodeHandle);
195             return this;
196         }
197         
198         public int next()
199         {
200             if (_currentNode == END)
201                 return END;
202             
203             _currentNode = END;
204             
205             if (_type != NO_TYPE) {
206                 if ((_currentNode == RTF_ROOT && _type == DTM.ROOT_NODE)
207                     || (_currentNode == RTF_TEXT && _type == DTM.TEXT_NODE))
208                     return getNodeHandle(_currentNode);
209             }
210             else
211                 return getNodeHandle(_currentNode);
212             
213             return END;                
214         }
215         
216     }  // END of SingletonIterator
217 
218     // empty iterator to be returned when there are no children
219     private final static DTMAxisIterator EMPTY_ITERATOR =
220         new DTMAxisIteratorBase() {
221             public DTMAxisIterator reset() { return this; }
222             public DTMAxisIterator setStartNode(int node) { return this; }
223             public int next() { return DTM.NULL; }
224             public void setMark() {}
225             public void gotoMark() {}
226             public int getLast() { return 0; }
227             public int getPosition() { return 0; }
228             public DTMAxisIterator cloneIterator() { return this; }
229             public void setRestartable(boolean isRestartable) { }
230         };
231     
232     
233     // The root node id of the simple RTF
234     public static final int RTF_ROOT = 0;
235     
236     // The Text node id of the simple RTF (simple RTF has only one Text node).
237     public static final int RTF_TEXT = 1;
238     
239     // The number of nodes.
240     public static final int NUMBER_OF_NODES = 2;
241     
242     // Document URI index, which increases by 1 at each getDocumentURI() call.
243     private static int _documentURIIndex = 0;
244     
245     // Constant for empty String
246     private static final String   EMPTY_STR = "";
247     
248     // The String value of the Text node.
249     // This is set at the endDocument() call.
250     private String   _text;
251     
252     // The array of Text items, which is built by the characters() call.
253     // The characters() interface can be called multiple times. Each character item
254     // can have different escape settings.
255     protected String  [] _textArray;
256     
257     // The DTMManager
258     protected XSLTCDTMManager _dtmManager;
259     
260     // Number of character items
261     protected int _size = 0;
262     
263     // The document ID
264     private int _documentID;
265 
266     // A BitArray, each bit holding the escape setting for a character item.
267     private BitArray _dontEscape = null;
268     
269     // The current escape setting
270     private boolean _escaping = true;
271     
272     // Create a SimpleResultTreeImpl from a DTMManager and a document ID.
273     public SimpleResultTreeImpl(XSLTCDTMManager dtmManager, int documentID)
274     {
275         _dtmManager = dtmManager;
276         _documentID = documentID;
277         _textArray = new String  [4];
278     }
279     
280     public DTMManagerDefault getDTMManager()
281     {
282         return _dtmManager; 
283     }
284     
285     // Return the document ID
286     public int getDocument()
287     {
288         return _documentID;
289     }
290 
291     // Return the String value of the RTF
292     public String   getStringValue()
293     {
294         return _text;
295     }
296     
297     public DTMAxisIterator getIterator()
298     {
299         return new SingletonIterator(getDocument());
300     }
301     
302     public DTMAxisIterator getChildren(final int node)
303     {
304         return new SimpleIterator().setStartNode(node);
305     }
306     
307     public DTMAxisIterator getTypedChildren(final int type)
308     {
309         return new SimpleIterator(SimpleIterator.DIRECTION_DOWN, type);
310     }
311     
312     // Return the axis iterator for a given axis.
313     // The SimpleIterator is used for the child, descendant, parent and ancestor axes.
314     public DTMAxisIterator getAxisIterator(final int axis)
315     {
316         switch (axis)
317         {
318             case Axis.CHILD:
319             case Axis.DESCENDANT:
320                 return new SimpleIterator(SimpleIterator.DIRECTION_DOWN);
321             case Axis.PARENT:
322             case Axis.ANCESTOR:
323                 return new SimpleIterator(SimpleIterator.DIRECTION_UP);
324             case Axis.ANCESTORORSELF:
325                 return (new SimpleIterator(SimpleIterator.DIRECTION_UP)).includeSelf();
326             case Axis.DESCENDANTORSELF:
327                 return (new SimpleIterator(SimpleIterator.DIRECTION_DOWN)).includeSelf();
328             case Axis.SELF:
329                 return new SingletonIterator();
330             default:
331                 return EMPTY_ITERATOR;
332         }
333     }
334     
335     public DTMAxisIterator getTypedAxisIterator(final int axis, final int type)
336     {
337         switch (axis)
338         {
339             case Axis.CHILD:
340             case Axis.DESCENDANT:
341                 return new SimpleIterator(SimpleIterator.DIRECTION_DOWN, type);
342             case Axis.PARENT:
343             case Axis.ANCESTOR:
344                 return new SimpleIterator(SimpleIterator.DIRECTION_UP, type);
345             case Axis.ANCESTORORSELF:
346                 return (new SimpleIterator(SimpleIterator.DIRECTION_UP, type)).includeSelf();
347             case Axis.DESCENDANTORSELF:
348                 return (new SimpleIterator(SimpleIterator.DIRECTION_DOWN, type)).includeSelf();
349             case Axis.SELF:
350                 return new SingletonIterator(type);
351             default:
352                 return EMPTY_ITERATOR;
353         }
354     }
355     
356     // %REVISIT% Can this one ever get used?
357     public DTMAxisIterator getNthDescendant(int node, int n, boolean includeself)
358     {
359         return null; 
360     }
361     
362     public DTMAxisIterator getNamespaceAxisIterator(final int axis, final int ns)
363     {
364         return null;
365     }
366     
367     // %REVISIT% Can this one ever get used?
368     public DTMAxisIterator getNodeValueIterator(DTMAxisIterator iter, int returnType,
369                          String   value, boolean op)
370     {
371         return null;
372     }
373     
374     public DTMAxisIterator orderNodes(DTMAxisIterator source, int node)
375     {
376         return source;
377     }
378     
379     public String   getNodeName(final int node)
380     {
381         if (getNodeIdent(node) == RTF_TEXT)
382             return "#text";
383         else
384             return EMPTY_STR;
385     }
386     
387     public String   getNodeNameX(final int node)
388     {
389         return EMPTY_STR;
390     }
391     
392     public String   getNamespaceName(final int node)
393     {
394         return EMPTY_STR;
395     }
396     
397     // Return the expanded type id of a given node
398     public int getExpandedTypeID(final int nodeHandle)
399     {
400         int nodeID = getNodeIdent(nodeHandle);
401         if (nodeID == RTF_TEXT)
402             return DTM.TEXT_NODE;
403         else if (nodeID == RTF_ROOT)
404             return DTM.ROOT_NODE;
405         else
406             return DTM.NULL;
407     }
408     
409     public int getNamespaceType(final int node)
410     {
411         return 0;
412     }
413     
414     public int getParent(final int nodeHandle)
415     {
416         int nodeID = getNodeIdent(nodeHandle);
417         return (nodeID == RTF_TEXT) ? getNodeHandle(RTF_ROOT) : DTM.NULL;            
418     }
419     
420     public int getAttributeNode(final int gType, final int element)
421     {
422         return DTM.NULL;
423     }
424     
425     public String   getStringValueX(final int nodeHandle)
426     {
427         int nodeID = getNodeIdent(nodeHandle);
428         if (nodeID == RTF_ROOT || nodeID == RTF_TEXT)
429             return _text;
430         else
431             return EMPTY_STR;
432     }
433     
434     public void copy(final int node, SerializationHandler handler)
435     throws TransletException
436     {
437         characters(node, handler);
438     }
439     
440     public void copy(DTMAxisIterator nodes, SerializationHandler handler)
441     throws TransletException
442     {
443         int node;
444         while ((node = nodes.next()) != DTM.NULL)
445         {
446             copy(node, handler);
447         }
448     }
449     
450     public String   shallowCopy(final int node, SerializationHandler handler)
451     throws TransletException
452     {
453         characters(node, handler);
454         return null;
455     }
456     
457     public boolean lessThan(final int node1, final int node2)
458     {
459         if (node1 == DTM.NULL) {
460             return false;
461         }
462         else if (node2 == DTM.NULL) {
463             return true;
464         }
465         else
466             return (node1 < node2);
467     }
468     
469     /**
470      * Dispatch the character content of a node to an output handler.
471      *
472      * The escape setting should be taken care of when outputting to
473      * a handler.
474      */
475     public void characters(final int node, SerializationHandler handler)
476         throws TransletException
477     {
478         int nodeID = getNodeIdent(node);
479         if (nodeID == RTF_ROOT || nodeID == RTF_TEXT) {
480             boolean escapeBit = false;
481             boolean oldEscapeSetting = false;
482 
483             try {
484                 for (int i = 0; i < _size; i++) {
485 
486                     if (_dontEscape != null) {
487                         escapeBit = _dontEscape.getBit(i);
488                         if (escapeBit) {
489                             oldEscapeSetting = handler.setEscaping(false);
490                         }
491                     }
492                 
493                     handler.characters(_textArray[i]);
494                 
495                     if (escapeBit) {
496                         handler.setEscaping(oldEscapeSetting);
497                     }
498                 }
499             } catch (SAXException   e) {
500                 throw new TransletException(e);
501             }
502         }
503     }
504     
505     // %REVISIT% Can the makeNode() and makeNodeList() interfaces ever get used?
506     public Node   makeNode(int index)
507     {
508         return null;
509     }
510     
511     public Node   makeNode(DTMAxisIterator iter)
512     {
513         return null;
514     }
515     
516     public NodeList   makeNodeList(int index)
517     {
518         return null;
519     }
520     
521     public NodeList   makeNodeList(DTMAxisIterator iter)
522     {
523         return null;
524     }
525     
526     public String   getLanguage(int node)
527     {
528         return null;
529     }
530     
531     public int getSize()
532     {
533         return 2;
534     }
535     
536     public String   getDocumentURI(int node)
537     {
538         return "simple_rtf" + _documentURIIndex++;
539     }
540     
541     public void setFilter(StripFilter filter)
542     {
543     }
544     
545     public void setupMapping(String  [] names, String  [] uris, int[] types, String  [] namespaces)
546     {
547     }
548     
549     public boolean isElement(final int node)
550     {
551         return false;
552     }
553     
554     public boolean isAttribute(final int node)
555     {
556         return false;
557     }
558     
559     public String   lookupNamespace(int node, String   prefix)
560     throws TransletException
561     {
562         return null;
563     }
564     
565     /**
566      * Return the node identity from a node handle.
567      */
568     public int getNodeIdent(final int nodehandle)
569     {
570         return (nodehandle != DTM.NULL) ? (nodehandle - _documentID) : DTM.NULL;
571     }
572     
573     /**
574      * Return the node handle from a node identity.
575      */
576     public int getNodeHandle(final int nodeId)
577     {
578         return (nodeId != DTM.NULL) ? (nodeId + _documentID) : DTM.NULL;
579     }
580     
581     public DOM getResultTreeFrag(int initialSize, int rtfType)
582     {
583         return null;
584     }
585     
586     public DOM getResultTreeFrag(int initialSize, int rtfType, boolean addToManager)
587     {
588         return null;
589     }
590     
591     public SerializationHandler getOutputDomBuilder()
592     {
593         return this;
594     }
595     
596     public int getNSType(int node)
597     {
598         return 0;
599     }
600     
601     public String   getUnparsedEntityURI(String   name)
602     {
603         return null;
604     }
605     
606     public Hashtable getElementsWithIDs()
607     {
608         return null;
609     }
610 
611     /** Implementation of the SerializationHandler interfaces **/
612     
613     /**
614      * We only need to override the endDocument, characters, and 
615      * setEscaping interfaces. A simple RTF does not have element
616      * nodes. We do not need to touch startElement and endElement.
617      */
618     
619     public void startDocument() throws SAXException  
620     {
621     
622     }
623     
624     public void endDocument() throws SAXException  
625     {
626         // Set the String value when the document is built.
627         if (_size == 1)
628             _text = _textArray[0];
629         else {
630             StringBuffer   buffer = new StringBuffer  ();
631             for (int i = 0; i < _size; i++) {
632                 buffer.append(_textArray[i]);
633             }
634             _text = buffer.toString();
635         }
636     }
637 
638     public void characters(String   str) throws SAXException  
639     {
640         // Resize the text array if necessary
641         if (_size >= _textArray.length) {
642             String  [] newTextArray = new String  [_textArray.length * 2];
643             System.arraycopy(_textArray, 0, newTextArray, 0, _textArray.length);
644             _textArray = newTextArray;
645         }
646         
647         // If the escape setting is false, set the corresponding bit in
648         // the _dontEscape BitArray.
649         if (!_escaping) {
650             // The _dontEscape array is only created when needed.
651             if (_dontEscape == null) {
652                 _dontEscape = new BitArray(8);
653             }
654             
655             // Resize the _dontEscape array if necessary
656             if (_size >= _dontEscape.size())
657                 _dontEscape.resize(_dontEscape.size() * 2);
658             
659             _dontEscape.setBit(_size);
660         }
661         
662         _textArray[_size++] = str;
663     }
664     
665     public void characters(char[] ch, int offset, int length)
666     throws SAXException  
667     {
668         if (_size >= _textArray.length) {
669             String  [] newTextArray = new String  [_textArray.length * 2];
670             System.arraycopy(_textArray, 0, newTextArray, 0, _textArray.length);
671             _textArray = newTextArray;
672         }
673 
674         if (!_escaping) {
675             if (_dontEscape == null) {
676                 _dontEscape = new BitArray(8);
677             }
678             
679             if (_size >= _dontEscape.size())
680                 _dontEscape.resize(_dontEscape.size() * 2);
681             
682             _dontEscape.setBit(_size);
683         }
684        
685         _textArray[_size++] = new String  (ch, offset, length);
686         
687     }
688     
689     public boolean setEscaping(boolean escape) throws SAXException  
690     {
691         final boolean temp = _escaping;
692         _escaping = escape; 
693         return temp;
694     }
695         
696     /** Implementation of the DTM interfaces **/
697     
698     /**
699      * The DTM interfaces are not used in this class. Implementing the DTM
700      * interface is a requirement from MultiDOM. If we have a better way
701      * of handling multiple documents, we can get rid of the DTM dependency.
702      *
703      * The following interfaces are just placeholders. The implementation
704      * does not have an impact because they will not be used.
705      */
706      
707     public void setFeature(String   featureId, boolean state)
708     {
709     }
710     
711     public void setProperty(String   property, Object   value)
712     {
713     }
714     
715     public DTMAxisTraverser getAxisTraverser(final int axis)
716     {
717         return null;
718     }
719     
720     public boolean hasChildNodes(int nodeHandle)
721     {
722         return (getNodeIdent(nodeHandle) == RTF_ROOT);
723     }
724     
725     public int getFirstChild(int nodeHandle)
726     {
727         int nodeID = getNodeIdent(nodeHandle);
728         if (nodeID == RTF_ROOT)
729             return getNodeHandle(RTF_TEXT);
730         else
731             return DTM.NULL;
732     }
733     
734     public int getLastChild(int nodeHandle)
735     {
736         return getFirstChild(nodeHandle);
737     }
738     
739     public int getAttributeNode(int elementHandle, String   namespaceURI, String   name)
740     {
741         return DTM.NULL;
742     }
743     
744     public int getFirstAttribute(int nodeHandle)
745     {
746         return DTM.NULL;
747     }
748     
749     public int getFirstNamespaceNode(int nodeHandle, boolean inScope)
750     {
751         return DTM.NULL;
752     }
753     
754     public int getNextSibling(int nodeHandle)
755     {
756         return DTM.NULL;
757     }
758     
759     public int getPreviousSibling(int nodeHandle)
760     {
761         return DTM.NULL;
762     }
763     
764     public int getNextAttribute(int nodeHandle)
765     {
766         return DTM.NULL;
767     }
768     
769     public int getNextNamespaceNode(int baseHandle, int namespaceHandle,
770                                   boolean inScope)
771     {
772         return DTM.NULL;
773     }
774     
775     public int getOwnerDocument(int nodeHandle)
776     {
777         return getDocument();
778     }
779     
780     public int getDocumentRoot(int nodeHandle)
781     {
782         return getDocument();
783     }
784     
785     public XMLString getStringValue(int nodeHandle)
786     {
787         return new XMLStringDefault(getStringValueX(nodeHandle));
788     }
789     
790     public int getStringValueChunkCount(int nodeHandle)
791     {
792         return 0;
793     }
794     
795     public char[] getStringValueChunk(int nodeHandle, int chunkIndex,
796                                     int[] startAndLen)
797     {
798         return null;
799     }
800     
801     public int getExpandedTypeID(String   namespace, String   localName, int type)
802     {
803         return DTM.NULL;
804     }
805     
806     public String   getLocalNameFromExpandedNameID(int ExpandedNameID)
807     {
808         return EMPTY_STR;
809     }
810     
811     public String   getNamespaceFromExpandedNameID(int ExpandedNameID)
812     {
813         return EMPTY_STR;
814     }
815     
816     public String   getLocalName(int nodeHandle)
817     {
818         return EMPTY_STR;
819     }
820     
821     public String   getPrefix(int nodeHandle)
822     {
823         return null;
824     }
825     
826     public String   getNamespaceURI(int nodeHandle)
827     {
828         return EMPTY_STR;
829     }
830     
831     public String   getNodeValue(int nodeHandle)
832     {
833         return (getNodeIdent(nodeHandle) == RTF_TEXT) ? _text : null;
834     }
835     
836     public short getNodeType(int nodeHandle)
837     {
838         int nodeID = getNodeIdent(nodeHandle);
839         if (nodeID == RTF_TEXT)
840             return DTM.TEXT_NODE;
841         else if (nodeID == RTF_ROOT)
842             return DTM.ROOT_NODE;
843         else
844             return DTM.NULL;
845         
846     }
847     
848     public short getLevel(int nodeHandle)
849     {
850         int nodeID = getNodeIdent(nodeHandle);
851         if (nodeID == RTF_TEXT)
852             return 2;
853         else if (nodeID == RTF_ROOT)
854             return 1;
855         else
856             return DTM.NULL;            
857     }
858     
859     public boolean isSupported(String   feature, String   version)
860     {
861         return false;
862     }
863     
864     public String   getDocumentBaseURI()
865     {
866         return EMPTY_STR;
867     }
868     
869     public void setDocumentBaseURI(String   baseURI)
870     {
871     }
872     
873     public String   getDocumentSystemIdentifier(int nodeHandle)
874     {
875         return null;
876     }
877     
878     public String   getDocumentEncoding(int nodeHandle)
879     {
880         return null;
881     }
882     
883     public String   getDocumentStandalone(int nodeHandle)
884     {
885         return null;
886     }
887     
888     public String   getDocumentVersion(int documentHandle)
889     {
890         return null;
891     }
892     
893     public boolean getDocumentAllDeclarationsProcessed()
894     {
895         return false;
896     }
897     
898     public String   getDocumentTypeDeclarationSystemIdentifier()
899     {
900         return null;
901     }
902     
903     public String   getDocumentTypeDeclarationPublicIdentifier()
904     {
905         return null;
906     }
907     
908     public int getElementById(String   elementId)
909     {
910         return DTM.NULL;
911     }
912         
913     public boolean supportsPreStripping()
914     {
915         return false;
916     }
917     
918     public boolean isNodeAfter(int firstNodeHandle, int secondNodeHandle)
919     {
920         return lessThan(firstNodeHandle, secondNodeHandle);
921     }
922     
923     public boolean isCharacterElementContentWhitespace(int nodeHandle)
924     {
925         return false;
926     }
927     
928     public boolean isDocumentAllDeclarationsProcessed(int documentHandle)
929     {
930         return false;
931     }
932     
933     public boolean isAttributeSpecified(int attributeHandle)
934     {
935         return false;
936     }
937     
938     public void dispatchCharactersEvents(
939         int nodeHandle,
940         org.xml.sax.ContentHandler   ch,
941         boolean normalize)
942           throws org.xml.sax.SAXException  
943     {
944     }
945     
946     public void dispatchToEvents(int nodeHandle, org.xml.sax.ContentHandler   ch)
947       throws org.xml.sax.SAXException  
948     {
949     }
950     
951     public org.w3c.dom.Node   getNode(int nodeHandle)
952     {
953         return makeNode(nodeHandle);
954     }
955     
956     public boolean needsTwoThreads()
957     {
958         return false;
959     }
960     
961     public org.xml.sax.ContentHandler   getContentHandler()
962     {
963         return null;
964     }
965     
966     public org.xml.sax.ext.LexicalHandler   getLexicalHandler()
967     {
968         return null;
969     }
970     
971     public org.xml.sax.EntityResolver   getEntityResolver()
972     {
973         return null;
974     }
975     
976     public org.xml.sax.DTDHandler   getDTDHandler()
977     {
978         return null;
979     }
980     
981     public org.xml.sax.ErrorHandler   getErrorHandler()
982     {
983         return null;
984     }
985     
986     public org.xml.sax.ext.DeclHandler   getDeclHandler()
987     {
988         return null;
989     }
990     
991     public void appendChild(int newChild, boolean clone, boolean cloneDepth)
992     {
993     }
994     
995     public void appendTextChild(String   str)
996     {
997     }
998     
999     public SourceLocator   getSourceLocatorFor(int node)
1000    {
1001        return null;
1002    }
1003    
1004    public void documentRegistration()
1005    {
1006    }
1007    
1008    public void documentRelease()
1009    {
1010    }
1011
1012    public void migrateTo(DTMManager manager)
1013    {
1014    }
1015}
1016
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags