001 /*
002 * Licensed to the Apache Software Foundation (ASF) under one
003 * or more contributor license agreements. See the NOTICE file
004 * distributed with this work for additional information
005 * regarding copyright ownership. The ASF licenses this file
006 * to you under the Apache License, Version 2.0 (the "License");
007 * you may not use this file except in compliance with the License.
008 * You may obtain a copy of the License at
009 *
010 * http://www.apache.org/licenses/LICENSE-2.0
011 *
012 * Unless required by applicable law or agreed to in writing, software
013 * distributed under the License is distributed on an "AS IS" BASIS,
014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015 * See the License for the specific language governing permissions and
016 * limitations under the License.
017 */
018 /*
019 * $Id: UnImplNode.java 468655 2006-10-28 07:12:06Z minchau $
020 */
021 package org.apache.xml.utils;
022
023 import org.apache.xml.res.XMLErrorResources;
024 import org.apache.xml.res.XMLMessages;
025
026 import org.w3c.dom.Attr;
027 import org.w3c.dom.CDATASection;
028 import org.w3c.dom.Comment;
029 import org.w3c.dom.DOMException;
030 import org.w3c.dom.DOMImplementation;
031 import org.w3c.dom.Document;
032 import org.w3c.dom.DocumentFragment;
033 import org.w3c.dom.DocumentType;
034 import org.w3c.dom.Element;
035 import org.w3c.dom.EntityReference;
036 import org.w3c.dom.NamedNodeMap;
037 import org.w3c.dom.Node;
038 import org.w3c.dom.NodeList;
039 import org.w3c.dom.ProcessingInstruction;
040 import org.w3c.dom.Text;
041
042 import org.w3c.dom.UserDataHandler;
043 import org.w3c.dom.DOMConfiguration;
044 import org.w3c.dom.TypeInfo;
045 /**
046 * To be subclassed by classes that wish to fake being nodes.
047 * @xsl.usage internal
048 */
049 public class UnImplNode implements Node, Element, NodeList, Document
050 {
051
052 /**
053 * Constructor UnImplNode
054 *
055 */
056 public UnImplNode(){}
057
058 /**
059 * Throw an error.
060 *
061 * @param msg Message Key for the error
062 */
063 public void error(String msg)
064 {
065
066 System.out.println("DOM ERROR! class: " + this.getClass().getName());
067
068 throw new RuntimeException(XMLMessages.createXMLMessage(msg, null));
069 }
070
071 /**
072 * Throw an error.
073 *
074 * @param msg Message Key for the error
075 * @param args Array of arguments to be used in the error message
076 */
077 public void error(String msg, Object[] args)
078 {
079
080 System.out.println("DOM ERROR! class: " + this.getClass().getName());
081
082 throw new RuntimeException(XMLMessages.createXMLMessage(msg, args)); //"UnImplNode error: "+msg);
083 }
084
085 /**
086 * Unimplemented. See org.w3c.dom.Node
087 *
088 * @param newChild New node to append to the list of this node's children
089 *
090 * @return null
091 *
092 * @throws DOMException
093 */
094 public Node appendChild(Node newChild) throws DOMException
095 {
096
097 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"appendChild not supported!");
098
099 return null;
100 }
101
102 /**
103 * Unimplemented. See org.w3c.dom.Node
104 *
105 * @return false
106 */
107 public boolean hasChildNodes()
108 {
109
110 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"hasChildNodes not supported!");
111
112 return false;
113 }
114
115 /**
116 * Unimplemented. See org.w3c.dom.Node
117 *
118 * @return 0
119 */
120 public short getNodeType()
121 {
122
123 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getNodeType not supported!");
124
125 return 0;
126 }
127
128 /**
129 * Unimplemented. See org.w3c.dom.Node
130 *
131 * @return null
132 */
133 public Node getParentNode()
134 {
135
136 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getParentNode not supported!");
137
138 return null;
139 }
140
141 /**
142 * Unimplemented. See org.w3c.dom.Node
143 *
144 * @return null
145 */
146 public NodeList getChildNodes()
147 {
148
149 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getChildNodes not supported!");
150
151 return null;
152 }
153
154 /**
155 * Unimplemented. See org.w3c.dom.Node
156 *
157 * @return null
158 */
159 public Node getFirstChild()
160 {
161
162 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getFirstChild not supported!");
163
164 return null;
165 }
166
167 /**
168 * Unimplemented. See org.w3c.dom.Node
169 *
170 * @return null
171 */
172 public Node getLastChild()
173 {
174
175 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getLastChild not supported!");
176
177 return null;
178 }
179
180 /**
181 * Unimplemented. See org.w3c.dom.Node
182 *
183 * @return null
184 */
185 public Node getNextSibling()
186 {
187
188 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getNextSibling not supported!");
189
190 return null;
191 }
192
193 /**
194 * Unimplemented. See org.w3c.dom.NodeList
195 *
196 * @return 0
197 */
198 public int getLength()
199 {
200
201 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getLength not supported!");
202
203 return 0;
204 } // getLength():int
205
206 /**
207 * Unimplemented. See org.w3c.dom.NodeList
208 *
209 * @param index index of a child of this node in its list of children
210 *
211 * @return null
212 */
213 public Node item(int index)
214 {
215
216 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"item not supported!");
217
218 return null;
219 } // item(int):Node
220
221 /**
222 * Unimplemented. See org.w3c.dom.Node
223 *
224 * @return null
225 */
226 public Document getOwnerDocument()
227 {
228
229 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getOwnerDocument not supported!");
230
231 return null;
232 }
233
234 /**
235 * Unimplemented. See org.w3c.dom.Node
236 *
237 * @return null
238 */
239 public String getTagName()
240 {
241
242 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getTagName not supported!");
243
244 return null;
245 }
246
247 /**
248 * Unimplemented. See org.w3c.dom.Node
249 *
250 * @return null
251 */
252 public String getNodeName()
253 {
254
255 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getNodeName not supported!");
256
257 return null;
258 }
259
260 /** Unimplemented. See org.w3c.dom.Node */
261 public void normalize()
262 {
263 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"normalize not supported!");
264 }
265
266 /**
267 * Unimplemented. See org.w3c.dom.Element
268 *
269 * @param name Name of the element
270 *
271 * @return null
272 */
273 public NodeList getElementsByTagName(String name)
274 {
275
276 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getElementsByTagName not supported!");
277
278 return null;
279 }
280
281 /**
282 * Unimplemented. See org.w3c.dom.Element
283 *
284 * @param oldAttr Attribute to be removed from this node's list of attributes
285 *
286 * @return null
287 *
288 * @throws DOMException
289 */
290 public Attr removeAttributeNode(Attr oldAttr) throws DOMException
291 {
292
293 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"removeAttributeNode not supported!");
294
295 return null;
296 }
297
298 /**
299 * Unimplemented. See org.w3c.dom.Element
300 *
301 * @param newAttr Attribute node to be added to this node's list of attributes
302 *
303 * @return null
304 *
305 * @throws DOMException
306 */
307 public Attr setAttributeNode(Attr newAttr) throws DOMException
308 {
309
310 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"setAttributeNode not supported!");
311
312 return null;
313 }
314
315 /**
316 * Unimplemented. See org.w3c.dom.Element
317 *
318 *
319 * @param name Name of an attribute
320 *
321 * @return false
322 */
323 public boolean hasAttribute(String name)
324 {
325
326 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"hasAttribute not supported!");
327
328 return false;
329 }
330
331 /**
332 * Unimplemented. See org.w3c.dom.Element
333 *
334 *
335 * @param name
336 * @param x
337 *
338 * @return false
339 */
340 public boolean hasAttributeNS(String name, String x)
341 {
342
343 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"hasAttributeNS not supported!");
344
345 return false;
346 }
347
348 /**
349 * Unimplemented. See org.w3c.dom.Element
350 *
351 *
352 * @param name Attribute node name
353 *
354 * @return null
355 */
356 public Attr getAttributeNode(String name)
357 {
358
359 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getAttributeNode not supported!");
360
361 return null;
362 }
363
364 /**
365 * Unimplemented. See org.w3c.dom.Element
366 *
367 * @param name Attribute node name to remove from list of attributes
368 *
369 * @throws DOMException
370 */
371 public void removeAttribute(String name) throws DOMException
372 {
373 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"removeAttribute not supported!");
374 }
375
376 /**
377 * Unimplemented. See org.w3c.dom.Element
378 *
379 * @param name Name of attribute to set
380 * @param value Value of attribute
381 *
382 * @throws DOMException
383 */
384 public void setAttribute(String name, String value) throws DOMException
385 {
386 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"setAttribute not supported!");
387 }
388
389 /**
390 * Unimplemented. See org.w3c.dom.Element
391 *
392 * @param name Name of attribute to get
393 *
394 * @return null
395 */
396 public String getAttribute(String name)
397 {
398
399 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getAttribute not supported!");
400
401 return null;
402 }
403
404 /**
405 * Unimplemented. Introduced in DOM Level 2.
406 *
407 * @return false
408 */
409 public boolean hasAttributes()
410 {
411
412 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"hasAttributes not supported!");
413
414 return false;
415 }
416
417 /**
418 * Unimplemented. See org.w3c.dom.Element
419 *
420 * @param namespaceURI Namespace URI of the element
421 * @param localName Local part of qualified name of the element
422 *
423 * @return null
424 */
425 public NodeList getElementsByTagNameNS(String namespaceURI,
426 String localName)
427 {
428
429 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getElementsByTagNameNS not supported!");
430
431 return null;
432 }
433
434 /**
435 * Unimplemented. See org.w3c.dom.Element
436 *
437 * @param newAttr Attribute to set
438 *
439 * @return null
440 *
441 * @throws DOMException
442 */
443 public Attr setAttributeNodeNS(Attr newAttr) throws DOMException
444 {
445
446 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"setAttributeNodeNS not supported!");
447
448 return null;
449 }
450
451 /**
452 * Unimplemented. See org.w3c.dom.Element
453 *
454 * @param namespaceURI Namespace URI of attribute node to get
455 * @param localName Local part of qualified name of attribute node to get
456 *
457 * @return null
458 */
459 public Attr getAttributeNodeNS(String namespaceURI, String localName)
460 {
461
462 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getAttributeNodeNS not supported!");
463
464 return null;
465 }
466
467 /**
468 * Unimplemented. See org.w3c.dom.Element
469 *
470 * @param namespaceURI Namespace URI of attribute node to remove
471 * @param localName Local part of qualified name of attribute node to remove
472 *
473 * @throws DOMException
474 */
475 public void removeAttributeNS(String namespaceURI, String localName)
476 throws DOMException
477 {
478 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"removeAttributeNS not supported!");
479 }
480
481 /**
482 * Unimplemented. See org.w3c.dom.Element
483 *
484 * @param namespaceURI Namespace URI of attribute node to set
485 * NEEDSDOC @param qualifiedName
486 * @param value value of attribute
487 *
488 * @throws DOMException
489 */
490 public void setAttributeNS(
491 String namespaceURI, String qualifiedName, String value)
492 throws DOMException
493 {
494 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"setAttributeNS not supported!");
495 }
496
497 /**
498 * Unimplemented. See org.w3c.dom.Element
499 *
500 * @param namespaceURI Namespace URI of attribute node to get
501 * @param localName Local part of qualified name of attribute node to get
502 *
503 * @return null
504 */
505 public String getAttributeNS(String namespaceURI, String localName)
506 {
507
508 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getAttributeNS not supported!");
509
510 return null;
511 }
512
513 /**
514 * Unimplemented. See org.w3c.dom.Node
515 *
516 * @return null
517 */
518 public Node getPreviousSibling()
519 {
520
521 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getPreviousSibling not supported!");
522
523 return null;
524 }
525
526 /**
527 * Unimplemented. See org.w3c.dom.Node
528 *
529 * @param deep Flag indicating whether to clone deep (clone member variables)
530 *
531 * @return null
532 */
533 public Node cloneNode(boolean deep)
534 {
535
536 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"cloneNode not supported!");
537
538 return null;
539 }
540
541 /**
542 * Unimplemented. See org.w3c.dom.Node
543 *
544 * @return null
545 *
546 * @throws DOMException
547 */
548 public String getNodeValue() throws DOMException
549 {
550
551 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getNodeValue not supported!");
552
553 return null;
554 }
555
556 /**
557 * Unimplemented. See org.w3c.dom.Node
558 *
559 * @param nodeValue Value to set this node to
560 *
561 * @throws DOMException
562 */
563 public void setNodeValue(String nodeValue) throws DOMException
564 {
565 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"setNodeValue not supported!");
566 }
567
568 /**
569 * Unimplemented. See org.w3c.dom.Node
570 *
571 *
572 * NEEDSDOC @param value
573 * @return value Node value
574 *
575 * @throws DOMException
576 */
577
578 // public String getValue ()
579 // {
580 // error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getValue not supported!");
581 // return null;
582 // }
583
584 /**
585 * Unimplemented. See org.w3c.dom.Node
586 *
587 * @param value Value to set this node to
588 *
589 * @throws DOMException
590 */
591 public void setValue(String value) throws DOMException
592 {
593 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"setValue not supported!");
594 }
595
596 /**
597 * Returns the name of this attribute.
598 *
599 * @return the name of this attribute.
600 */
601
602 // public String getName()
603 // {
604 // return this.getNodeName();
605 // }
606
607 /**
608 * Unimplemented. See org.w3c.dom.Node
609 *
610 * @return null
611 */
612 public Element getOwnerElement()
613 {
614
615 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getOwnerElement not supported!");
616
617 return null;
618 }
619
620 /**
621 * Unimplemented. See org.w3c.dom.Node
622 *
623 * @return False
624 */
625 public boolean getSpecified()
626 {
627
628 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"setValue not supported!");
629
630 return false;
631 }
632
633 /**
634 * Unimplemented. See org.w3c.dom.Node
635 *
636 * @return null
637 */
638 public NamedNodeMap getAttributes()
639 {
640
641 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getAttributes not supported!");
642
643 return null;
644 }
645
646 /**
647 * Unimplemented. See org.w3c.dom.Node
648 *
649 * @param newChild New child node to insert
650 * @param refChild Insert in front of this child
651 *
652 * @return null
653 *
654 * @throws DOMException
655 */
656 public Node insertBefore(Node newChild, Node refChild) throws DOMException
657 {
658
659 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"insertBefore not supported!");
660
661 return null;
662 }
663
664 /**
665 * Unimplemented. See org.w3c.dom.Node
666 *
667 * @param newChild Replace existing child with this one
668 * @param oldChild Existing child to be replaced
669 *
670 * @return null
671 *
672 * @throws DOMException
673 */
674 public Node replaceChild(Node newChild, Node oldChild) throws DOMException
675 {
676
677 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"replaceChild not supported!");
678
679 return null;
680 }
681
682 /**
683 * Unimplemented. See org.w3c.dom.Node
684 *
685 * @param oldChild Child to be removed
686 *
687 * @return null
688 *
689 * @throws DOMException
690 */
691 public Node removeChild(Node oldChild) throws DOMException
692 {
693
694 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"replaceChild not supported!");
695
696 return null;
697 }
698
699 /**
700 * Tests whether the DOM implementation implements a specific feature and
701 * that feature is supported by this node.
702 * @param feature The name of the feature to test. This is the same name
703 * which can be passed to the method <code>hasFeature</code> on
704 * <code>DOMImplementation</code>.
705 * @param version This is the version number of the feature to test. In
706 * Level 2, version 1, this is the string "2.0". If the version is not
707 * specified, supporting any version of the feature will cause the
708 * method to return <code>true</code>.
709 *
710 * @return Returns <code>false</code>
711 * @since DOM Level 2
712 */
713 public boolean isSupported(String feature, String version)
714 {
715 return false;
716 }
717
718 /**
719 * Unimplemented. See org.w3c.dom.Node
720 *
721 * @return null
722 */
723 public String getNamespaceURI()
724 {
725
726 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getNamespaceURI not supported!");
727
728 return null;
729 }
730
731 /**
732 * Unimplemented. See org.w3c.dom.Node
733 *
734 * @return null
735 */
736 public String getPrefix()
737 {
738
739 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getPrefix not supported!");
740
741 return null;
742 }
743
744 /**
745 * Unimplemented. See org.w3c.dom.Node
746 *
747 * @param prefix Prefix to set for this node
748 *
749 * @throws DOMException
750 */
751 public void setPrefix(String prefix) throws DOMException
752 {
753 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"setPrefix not supported!");
754 }
755
756 /**
757 * Unimplemented. See org.w3c.dom.Node
758 *
759 * @return null
760 */
761 public String getLocalName()
762 {
763
764 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getLocalName not supported!");
765
766 return null;
767 }
768
769 /**
770 * Unimplemented. See org.w3c.dom.Document
771 *
772 * @return null
773 */
774 public DocumentType getDoctype()
775 {
776
777 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
778
779 return null;
780 }
781
782 /**
783 * Unimplemented. See org.w3c.dom.Document
784 *
785 * @return null
786 */
787 public DOMImplementation getImplementation()
788 {
789
790 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
791
792 return null;
793 }
794
795 /**
796 * Unimplemented. See org.w3c.dom.Document
797 *
798 * @return null
799 */
800 public Element getDocumentElement()
801 {
802
803 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
804
805 return null;
806 }
807
808 /**
809 * Unimplemented. See org.w3c.dom.Document
810 *
811 * @param tagName Element tag name
812 *
813 * @return null
814 *
815 * @throws DOMException
816 */
817 public Element createElement(String tagName) throws DOMException
818 {
819
820 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
821
822 return null;
823 }
824
825 /**
826 * Unimplemented. See org.w3c.dom.Document
827 *
828 * @return null
829 */
830 public DocumentFragment createDocumentFragment()
831 {
832
833 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
834
835 return null;
836 }
837
838 /**
839 * Unimplemented. See org.w3c.dom.Document
840 *
841 * @param data Data for text node
842 *
843 * @return null
844 */
845 public Text createTextNode(String data)
846 {
847
848 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
849
850 return null;
851 }
852
853 /**
854 * Unimplemented. See org.w3c.dom.Document
855 *
856 * @param data Data for comment
857 *
858 * @return null
859 */
860 public Comment createComment(String data)
861 {
862
863 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
864
865 return null;
866 }
867
868 /**
869 * Unimplemented. See org.w3c.dom.Document
870 *
871 * @param data Data for CDATA section
872 *
873 * @return null
874 *
875 * @throws DOMException
876 */
877 public CDATASection createCDATASection(String data) throws DOMException
878 {
879
880 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
881
882 return null;
883 }
884
885 /**
886 * Unimplemented. See org.w3c.dom.Document
887 *
888 * @param target Target for Processing instruction
889 * @param data Data for Processing instruction
890 *
891 * @return null
892 *
893 * @throws DOMException
894 */
895 public ProcessingInstruction createProcessingInstruction(
896 String target, String data) throws DOMException
897 {
898
899 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
900
901 return null;
902 }
903
904 /**
905 * Unimplemented. See org.w3c.dom.Document
906 *
907 * @param name Attribute name
908 *
909 * @return null
910 *
911 * @throws DOMException
912 */
913 public Attr createAttribute(String name) throws DOMException
914 {
915
916 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
917
918 return null;
919 }
920
921 /**
922 * Unimplemented. See org.w3c.dom.Document
923 *
924 * @param name Entity Reference name
925 *
926 * @return null
927 *
928 * @throws DOMException
929 */
930 public EntityReference createEntityReference(String name)
931 throws DOMException
932 {
933
934 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
935
936 return null;
937 }
938
939 /**
940 * Unimplemented. See org.w3c.dom.Document
941 *
942 * @param importedNode The node to import.
943 * @param deep If <code>true</code>, recursively import the subtree under
944 * the specified node; if <code>false</code>, import only the node
945 * itself, as explained above. This has no effect on <code>Attr</code>
946 * , <code>EntityReference</code>, and <code>Notation</code> nodes.
947 *
948 * @return null
949 *
950 * @throws DOMException
951 */
952 public Node importNode(Node importedNode, boolean deep) throws DOMException
953 {
954
955 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
956
957 return null;
958 }
959
960 /**
961 * Unimplemented. See org.w3c.dom.Document
962 *
963 * @param namespaceURI Namespace URI for the element
964 * @param qualifiedName Qualified name of the element
965 *
966 * @return null
967 *
968 * @throws DOMException
969 */
970 public Element createElementNS(String namespaceURI, String qualifiedName)
971 throws DOMException
972 {
973
974 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
975
976 return null;
977 }
978
979 /**
980 * Unimplemented. See org.w3c.dom.Document
981 *
982 * @param namespaceURI Namespace URI of the attribute
983 * @param qualifiedName Qualified name of the attribute
984 *
985 * @return null
986 *
987 * @throws DOMException
988 */
989 public Attr createAttributeNS(String namespaceURI, String qualifiedName)
990 throws DOMException
991 {
992
993 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
994
995 return null;
996 }
997
998 /**
999 * Unimplemented. See org.w3c.dom.Document
1000 *
1001 * @param elementId ID of the element to get
1002 *
1003 * @return null
1004 */
1005 public Element getElementById(String elementId)
1006 {
1007
1008 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
1009
1010 return null;
1011 }
1012
1013 /**
1014 * Set Node data
1015 *
1016 *
1017 * @param data data to set for this node
1018 *
1019 * @throws DOMException
1020 */
1021 public void setData(String data) throws DOMException
1022 {
1023 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
1024 }
1025
1026 /**
1027 * Unimplemented.
1028 *
1029 * @param offset Start offset of substring to extract.
1030 * @param count The length of the substring to extract.
1031 *
1032 * @return null
1033 *
1034 * @throws DOMException
1035 */
1036 public String substringData(int offset, int count) throws DOMException
1037 {
1038
1039 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
1040
1041 return null;
1042 }
1043
1044 /**
1045 * Unimplemented.
1046 *
1047 * @param arg String data to append
1048 *
1049 * @throws DOMException
1050 */
1051 public void appendData(String arg) throws DOMException
1052 {
1053 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
1054 }
1055
1056 /**
1057 * Unimplemented.
1058 *
1059 * @param offset Start offset of substring to insert.
1060 * NEEDSDOC @param arg
1061 *
1062 * @throws DOMException
1063 */
1064 public void insertData(int offset, String arg) throws DOMException
1065 {
1066 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
1067 }
1068
1069 /**
1070 * Unimplemented.
1071 *
1072 * @param offset Start offset of substring to delete.
1073 * @param count The length of the substring to delete.
1074 *
1075 * @throws DOMException
1076 */
1077 public void deleteData(int offset, int count) throws DOMException
1078 {
1079 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
1080 }
1081
1082 /**
1083 * Unimplemented.
1084 *
1085 * @param offset Start offset of substring to replace.
1086 * @param count The length of the substring to replace.
1087 * @param arg substring to replace with
1088 *
1089 * @throws DOMException
1090 */
1091 public void replaceData(int offset, int count, String arg)
1092 throws DOMException
1093 {
1094 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
1095 }
1096
1097 /**
1098 * Unimplemented.
1099 *
1100 * @param offset Offset into text to split
1101 *
1102 * @return null, unimplemented
1103 *
1104 * @throws DOMException
1105 */
1106 public Text splitText(int offset) throws DOMException
1107 {
1108
1109 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
1110
1111 return null;
1112 }
1113
1114 /**
1115 * NEEDSDOC Method adoptNode
1116 *
1117 *
1118 * NEEDSDOC @param source
1119 *
1120 * NEEDSDOC (adoptNode) @return
1121 *
1122 * @throws DOMException
1123 */
1124 public Node adoptNode(Node source) throws DOMException
1125 {
1126
1127 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
1128
1129 return null;
1130 }
1131
1132 /**
1133 * <p>Based on the <a
1134 * href='http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407'>Document
1135 * Object Model (DOM) Level 3 Core Specification of 07 April 2004.</a>.
1136 * <p>
1137 * An attribute specifying, as part of the XML declaration, the encoding
1138 * of this document. This is <code>null</code> when unspecified.
1139 * @since DOM Level 3
1140 *
1141 * NEEDSDOC ($objectName$) @return
1142 */
1143 public String getInputEncoding()
1144 {
1145
1146 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
1147
1148 return null;
1149 }
1150
1151 /**
1152 * <p>Based on the <a
1153 * href='http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407'>Document
1154 * Object Model (DOM) Level 3 Core Specification of 07 April 2004.</a>.
1155 * <p>
1156 * An attribute specifying, as part of the XML declaration, the encoding
1157 * of this document. This is <code>null</code> when unspecified.
1158 * @since DOM Level 3
1159 *
1160 * NEEDSDOC @param encoding
1161 */
1162 public void setInputEncoding(String encoding)
1163 {
1164 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
1165 }
1166
1167 /**
1168 * <p>Based on the <a
1169 * href='http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407'>Document
1170 * Object Model (DOM) Level 3 Core Specification of 07 April 2004.</a>.
1171 * <p>
1172 * An attribute specifying whether errors checking is enforced or not.
1173 * When set to <code>false</code>, the implementation is free to not
1174 * test every possible error case normally defined on DOM operations,
1175 * and not raise any <code>DOMException</code>. In case of error, the
1176 * behavior is undefined. This attribute is <code>true</code> by
1177 * defaults.
1178 * @since DOM Level 3
1179 *
1180 * NEEDSDOC ($objectName$) @return
1181 */
1182 public boolean getStrictErrorChecking()
1183 {
1184
1185 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
1186
1187 return false;
1188 }
1189
1190 /**
1191 * <p>Based on the <a
1192 * href='http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407'>Document
1193 * Object Model (DOM) Level 3 Core Specification of 07 April 2004.</a>.
1194 * <p>
1195 * An attribute specifying whether errors checking is enforced or not.
1196 * When set to <code>false</code>, the implementation is free to not
1197 * test every possible error case normally defined on DOM operations,
1198 * and not raise any <code>DOMException</code>. In case of error, the
1199 * behavior is undefined. This attribute is <code>true</code> by
1200 * defaults.
1201 * @since DOM Level 3
1202 *
1203 * NEEDSDOC @param strictErrorChecking
1204 */
1205 public void setStrictErrorChecking(boolean strictErrorChecking)
1206 {
1207 error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
1208 }
1209
1210 // RAMESH : Pending proper implementation of DOM Level 3
1211 public Object setUserData(String key,
1212 Object data,
1213 UserDataHandler handler) {
1214 return getOwnerDocument().setUserData( key, data, handler);
1215 }
1216
1217 /**
1218 * Retrieves the object associated to a key on a this node. The object
1219 * must first have been set to this node by calling
1220 * <code>setUserData</code> with the same key.
1221 * @param key The key the object is associated to.
1222 * @return Returns the <code>DOMObject</code> associated to the given key
1223 * on this node, or <code>null</code> if there was none.
1224 * @since DOM Level 3
1225 */
1226 public Object getUserData(String key) {
1227 return getOwnerDocument().getUserData( key);
1228 }
1229
1230 /**
1231 * This method returns a specialized object which implements the
1232 * specialized APIs of the specified feature and version. The
1233 * specialized object may also be obtained by using binding-specific
1234 * casting methods but is not necessarily expected to, as discussed in Mixed DOM implementations.
1235 * @param feature The name of the feature requested (case-insensitive).
1236 * @param version This is the version number of the feature to test. If
1237 * the version is <code>null</code> or the empty string, supporting
1238 * any version of the feature will cause the method to return an
1239 * object that supports at least one version of the feature.
1240 * @return Returns an object which implements the specialized APIs of
1241 * the specified feature and version, if any, or <code>null</code> if
1242 * there is no object which implements interfaces associated with that
1243 * feature. If the <code>DOMObject</code> returned by this method
1244 * implements the <code>Node</code> interface, it must delegate to the
1245 * primary core <code>Node</code> and not return results inconsistent
1246 * with the primary core <code>Node</code> such as attributes,
1247 * childNodes, etc.
1248 * @since DOM Level 3
1249 */
1250 public Object getFeature(String feature, String version) {
1251 // we don't have any alternate node, either this node does the job
1252 // or we don't have anything that does
1253 return isSupported(feature, version) ? this : null;
1254 }
1255
1256 /**
1257 * Tests whether two nodes are equal.
1258 * <br>This method tests for equality of nodes, not sameness (i.e.,
1259 * whether the two nodes are references to the same object) which can be
1260 * tested with <code>Node.isSameNode</code>. All nodes that are the same
1261 * will also be equal, though the reverse may not be true.
1262 * <br>Two nodes are equal if and only if the following conditions are
1263 * satisfied: The two nodes are of the same type.The following string
1264 * attributes are equal: <code>nodeName</code>, <code>localName</code>,
1265 * <code>namespaceURI</code>, <code>prefix</code>, <code>nodeValue</code>
1266 * , <code>baseURI</code>. This is: they are both <code>null</code>, or
1267 * they have the same length and are character for character identical.
1268 * The <code>attributes</code> <code>NamedNodeMaps</code> are equal.
1269 * This is: they are both <code>null</code>, or they have the same
1270 * length and for each node that exists in one map there is a node that
1271 * exists in the other map and is equal, although not necessarily at the
1272 * same index.The <code>childNodes</code> <code>NodeLists</code> are
1273 * equal. This is: they are both <code>null</code>, or they have the
1274 * same length and contain equal nodes at the same index. This is true
1275 * for <code>Attr</code> nodes as for any other type of node. Note that
1276 * normalization can affect equality; to avoid this, nodes should be
1277 * normalized before being compared.
1278 * <br>For two <code>DocumentType</code> nodes to be equal, the following
1279 * conditions must also be satisfied: The following string attributes
1280 * are equal: <code>publicId</code>, <code>systemId</code>,
1281 * <code>internalSubset</code>.The <code>entities</code>
1282 * <code>NamedNodeMaps</code> are equal.The <code>notations</code>
1283 * <code>NamedNodeMaps</code> are equal.
1284 * <br>On the other hand, the following do not affect equality: the
1285 * <code>ownerDocument</code> attribute, the <code>specified</code>
1286 * attribute for <code>Attr</code> nodes, the
1287 * <code>isWhitespaceInElementContent</code> attribute for
1288 * <code>Text</code> nodes, as well as any user data or event listeners
1289 * registered on the nodes.
1290 * @param arg The node to compare equality with.
1291 * @param deep If <code>true</code>, recursively compare the subtrees; if
1292 * <code>false</code>, compare only the nodes themselves (and its
1293 * attributes, if it is an <code>Element</code>).
1294 * @return If the nodes, and possibly subtrees are equal,
1295 * <code>true</code> otherwise <code>false</code>.
1296 * @since DOM Level 3
1297 */
1298 public boolean isEqualNode(Node arg) {
1299 if (arg == this) {
1300 return true;
1301 }
1302 if (arg.getNodeType() != getNodeType()) {
1303 return false;
1304 }
1305 // in theory nodeName can't be null but better be careful
1306 // who knows what other implementations may be doing?...
1307 if (getNodeName() == null) {
1308 if (arg.getNodeName() != null) {
1309 return false;
1310 }
1311 }
1312 else if (!getNodeName().equals(arg.getNodeName())) {
1313 return false;
1314 }
1315
1316 if (getLocalName() == null) {
1317 if (arg.getLocalName() != null) {
1318 return false;
1319 }
1320 }
1321 else if (!getLocalName().equals(arg.getLocalName())) {
1322 return false;
1323 }
1324
1325 if (getNamespaceURI() == null) {
1326 if (arg.getNamespaceURI() != null) {
1327 return false;
1328 }
1329 }
1330 else if (!getNamespaceURI().equals(arg.getNamespaceURI())) {
1331 return false;
1332 }
1333
1334 if (getPrefix() == null) {
1335 if (arg.getPrefix() != null) {
1336 return false;
1337 }
1338 }
1339 else if (!getPrefix().equals(arg.getPrefix())) {
1340 return false;
1341 }
1342
1343 if (getNodeValue() == null) {
1344 if (arg.getNodeValue() != null) {
1345 return false;
1346 }
1347 }
1348 else if (!getNodeValue().equals(arg.getNodeValue())) {
1349 return false;
1350 }
1351 /*
1352 if (getBaseURI() == null) {
1353 if (((NodeImpl) arg).getBaseURI() != null) {
1354 return false;
1355 }
1356 }
1357 else if (!getBaseURI().equals(((NodeImpl) arg).getBaseURI())) {
1358 return false;
1359 }
1360 */
1361
1362 return true;
1363 }
1364
1365 /**
1366 * DOM Level 3:
1367 * Look up the namespace URI associated to the given prefix, starting from this node.
1368 * Use lookupNamespaceURI(null) to lookup the default namespace
1369 *
1370 * @param namespaceURI
1371 * @return th URI for the namespace
1372 * @since DOM Level 3
1373 */
1374 public String lookupNamespaceURI(String specifiedPrefix) {
1375 short type = this.getNodeType();
1376 switch (type) {
1377 case Node.ELEMENT_NODE : {
1378
1379 String namespace = this.getNamespaceURI();
1380 String prefix = this.getPrefix();
1381 if (namespace !=null) {
1382 // REVISIT: is it possible that prefix is empty string?
1383 if (specifiedPrefix== null && prefix==specifiedPrefix) {
1384 // looking for default namespace
1385 return namespace;
1386 } else if (prefix != null && prefix.equals(specifiedPrefix)) {
1387 // non default namespace
1388 return namespace;
1389 }
1390 }
1391 if (this.hasAttributes()) {
1392 NamedNodeMap map = this.getAttributes();
1393 int length = map.getLength();
1394 for (int i=0;i<length;i++) {
1395 Node attr = map.item(i);
1396 String attrPrefix = attr.getPrefix();
1397 String value = attr.getNodeValue();
1398 namespace = attr.getNamespaceURI();
1399 if (namespace !=null && namespace.equals("http://www.w3.org/2000/xmlns/")) {
1400 // at this point we are dealing with DOM Level 2 nodes only
1401 if (specifiedPrefix == null &&
1402 attr.getNodeName().equals("xmlns")) {
1403 // default namespace
1404 return value;
1405 } else if (attrPrefix !=null &&
1406 attrPrefix.equals("xmlns") &&
1407 attr.getLocalName().equals(specifiedPrefix)) {
1408 // non default namespace
1409 return value;
1410 }
1411 }
1412 }
1413 }
1414 /*
1415 NodeImpl ancestor = (NodeImpl)getElementAncestor(this);
1416 if (ancestor != null) {
1417 return ancestor.lookupNamespaceURI(specifiedPrefix);
1418 }
1419 */
1420
1421 return null;
1422
1423
1424 }
1425 /*
1426 case Node.DOCUMENT_NODE : {
1427 return((NodeImpl)((Document)this).getDocumentElement()).lookupNamespaceURI(specifiedPrefix) ;
1428 }
1429 */
1430 case Node.ENTITY_NODE :
1431 case Node.NOTATION_NODE:
1432 case Node.DOCUMENT_FRAGMENT_NODE:
1433 case Node.DOCUMENT_TYPE_NODE:
1434 // type is unknown
1435 return null;
1436 case Node.ATTRIBUTE_NODE:{
1437 if (this.getOwnerElement().getNodeType() == Node.ELEMENT_NODE) {
1438 return getOwnerElement().lookupNamespaceURI(specifiedPrefix);
1439
1440 }
1441 return null;
1442 }
1443 default:{
1444 /*
1445 NodeImpl ancestor = (NodeImpl)getElementAncestor(this);
1446 if (ancestor != null) {
1447 return ancestor.lookupNamespaceURI(specifiedPrefix);
1448 }
1449 */
1450 return null;
1451 }
1452
1453 }
1454 }
1455
1456 /**
1457 * DOM Level 3:
1458 * This method checks if the specified <code>namespaceURI</code> is the
1459 * default namespace or not.
1460 * @param namespaceURI The namespace URI to look for.
1461 * @return <code>true</code> if the specified <code>namespaceURI</code>
1462 * is the default namespace, <code>false</code> otherwise.
1463 * @since DOM Level 3
1464 */
1465 public boolean isDefaultNamespace(String namespaceURI){
1466 /*
1467 // REVISIT: remove casts when DOM L3 becomes REC.
1468 short type = this.getNodeType();
1469 switch (type) {
1470 case Node.ELEMENT_NODE: {
1471 String namespace = this.getNamespaceURI();
1472 String prefix = this.getPrefix();
1473
1474 // REVISIT: is it possible that prefix is empty string?
1475 if (prefix == null || prefix.length() == 0) {
1476 if (namespaceURI == null) {
1477 return (namespace == namespaceURI);
1478 }
1479 return namespaceURI.equals(namespace);
1480 }
1481 if (this.hasAttributes()) {
1482 ElementImpl elem = (ElementImpl)this;
1483 NodeImpl attr = (NodeImpl)elem.getAttributeNodeNS("http://www.w3.org/2000/xmlns/", "xmlns");
1484 if (attr != null) {
1485 String value = attr.getNodeValue();
1486 if (namespaceURI == null) {
1487 return (namespace == value);
1488 }
1489 return namespaceURI.equals(value);
1490 }
1491 }
1492
1493 NodeImpl ancestor = (NodeImpl)getElementAncestor(this);
1494 if (ancestor != null) {
1495 return ancestor.isDefaultNamespace(namespaceURI);
1496 }
1497 return false;
1498 }
1499 case Node.DOCUMENT_NODE:{
1500 return((NodeImpl)((Document)this).getDocumentElement()).isDefaultNamespace(namespaceURI);
1501 }
1502
1503 case Node.ENTITY_NODE :
1504 case Node.NOTATION_NODE:
1505 case Node.DOCUMENT_FRAGMENT_NODE:
1506 case Node.DOCUMENT_TYPE_NODE:
1507 // type is unknown
1508 return false;
1509 case Node.ATTRIBUTE_NODE:{
1510 if (this.ownerNode.getNodeType() == Node.ELEMENT_NODE) {
1511 return ownerNode.isDefaultNamespace(namespaceURI);
1512
1513 }
1514 return false;
1515 }
1516 default:{
1517 NodeImpl ancestor = (NodeImpl)getElementAncestor(this);
1518 if (ancestor != null) {
1519 return ancestor.isDefaultNamespace(namespaceURI);
1520 }
1521 return false;
1522 }
1523
1524 }
1525 */
1526 return false;
1527
1528
1529 }
1530
1531 /**
1532 *
1533 * DOM Level 3:
1534 * Look up the prefix associated to the given namespace URI, starting from this node.
1535 *
1536 * @param namespaceURI
1537 * @return the prefix for the namespace
1538 */
1539 public String lookupPrefix(String namespaceURI){
1540
1541 // REVISIT: When Namespaces 1.1 comes out this may not be true
1542 // Prefix can't be bound to null namespace
1543 if (namespaceURI == null) {
1544 return null;
1545 }
1546
1547 short type = this.getNodeType();
1548
1549 switch (type) {
1550 /*
1551 case Node.ELEMENT_NODE: {
1552
1553 String namespace = this.getNamespaceURI(); // to flip out children
1554 return lookupNamespacePrefix(namespaceURI, (ElementImpl)this);
1555 }
1556
1557 case Node.DOCUMENT_NODE:{
1558 return((NodeImpl)((Document)this).getDocumentElement()).lookupPrefix(namespaceURI);
1559 }
1560 */
1561 case Node.ENTITY_NODE :
1562 case Node.NOTATION_NODE:
1563 case Node.DOCUMENT_FRAGMENT_NODE:
1564 case Node.DOCUMENT_TYPE_NODE:
1565 // type is unknown
1566 return null;
1567 case Node.ATTRIBUTE_NODE:{
1568 if (this.getOwnerElement().getNodeType() == Node.ELEMENT_NODE) {
1569 return getOwnerElement().lookupPrefix(namespaceURI);
1570
1571 }
1572 return null;
1573 }
1574 default:{
1575 /*
1576 NodeImpl ancestor = (NodeImpl)getElementAncestor(this);
1577 if (ancestor != null) {
1578 return ancestor.lookupPrefix(namespaceURI);
1579 }
1580 */
1581 return null;
1582 }
1583 }
1584 }
1585
1586 /**
1587 * Returns whether this node is the same node as the given one.
1588 * <br>This method provides a way to determine whether two
1589 * <code>Node</code> references returned by the implementation reference
1590 * the same object. When two <code>Node</code> references are references
1591 * to the same object, even if through a proxy, the references may be
1592 * used completely interchangably, such that all attributes have the
1593 * same values and calling the same DOM method on either reference
1594 * always has exactly the same effect.
1595 * @param other The node to test against.
1596 * @return Returns <code>true</code> if the nodes are the same,
1597 * <code>false</code> otherwise.
1598 * @since DOM Level 3
1599 */
1600 public boolean isSameNode(Node other) {
1601 // we do not use any wrapper so the answer is obvious
1602 return this == other;
1603 }
1604
1605 /**
1606 * This attribute returns the text content of this node and its
1607 * descendants. When it is defined to be null, setting it has no effect.
1608 * When set, any possible children this node may have are removed and
1609 * replaced by a single <code>Text</code> node containing the string
1610 * this attribute is set to. On getting, no serialization is performed,
1611 * the returned string does not contain any markup. No whitespace
1612 * normalization is performed, the returned string does not contain the
1613 * element content whitespaces . Similarly, on setting, no parsing is
1614 * performed either, the input string is taken as pure textual content.
1615 * <br>The string returned is made of the text content of this node
1616 * depending on its type, as defined below:
1617 * <table border='1'>
1618 * <tr>
1619 * <th>Node type</th>
1620 * <th>Content</th>
1621 * </tr>
1622 * <tr>
1623 * <td valign='top' rowspan='1' colspan='1'>
1624 * ELEMENT_NODE, ENTITY_NODE, ENTITY_REFERENCE_NODE,
1625 * DOCUMENT_FRAGMENT_NODE</td>
1626 * <td valign='top' rowspan='1' colspan='1'>concatenation of the <code>textContent</code>
1627 * attribute value of every child node, excluding COMMENT_NODE and
1628 * PROCESSING_INSTRUCTION_NODE nodes</td>
1629 * </tr>
1630 * <tr>
1631 * <td valign='top' rowspan='1' colspan='1'>ATTRIBUTE_NODE, TEXT_NODE,
1632 * CDATA_SECTION_NODE, COMMENT_NODE, PROCESSING_INSTRUCTION_NODE</td>
1633 * <td valign='top' rowspan='1' colspan='1'>
1634 * <code>nodeValue</code></td>
1635 * </tr>
1636 * <tr>
1637 * <td valign='top' rowspan='1' colspan='1'>DOCUMENT_NODE, DOCUMENT_TYPE_NODE, NOTATION_NODE</td>
1638 * <td valign='top' rowspan='1' colspan='1'>
1639 * null</td>
1640 * </tr>
1641 * </table>
1642 * @exception DOMException
1643 * NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
1644 * @exception DOMException
1645 * DOMSTRING_SIZE_ERR: Raised when it would return more characters than
1646 * fit in a <code>DOMString</code> variable on the implementation
1647 * platform.
1648 * @since DOM Level 3
1649 */
1650 public void setTextContent(String textContent)
1651 throws DOMException {
1652 setNodeValue(textContent);
1653 }
1654
1655 /**
1656 * This attribute returns the text content of this node and its
1657 * descendants. When it is defined to be null, setting it has no effect.
1658 * When set, any possible children this node may have are removed and
1659 * replaced by a single <code>Text</code> node containing the string
1660 * this attribute is set to. On getting, no serialization is performed,
1661 * the returned string does not contain any markup. No whitespace
1662 * normalization is performed, the returned string does not contain the
1663 * element content whitespaces . Similarly, on setting, no parsing is
1664 * performed either, the input string is taken as pure textual content.
1665 * <br>The string returned is made of the text content of this node
1666 * depending on its type, as defined below:
1667 * <table border='1'>
1668 * <tr>
1669 * <th>Node type</th>
1670 * <th>Content</th>
1671 * </tr>
1672 * <tr>
1673 * <td valign='top' rowspan='1' colspan='1'>
1674 * ELEMENT_NODE, ENTITY_NODE, ENTITY_REFERENCE_NODE,
1675 * DOCUMENT_FRAGMENT_NODE</td>
1676 * <td valign='top' rowspan='1' colspan='1'>concatenation of the <code>textContent</code>
1677 * attribute value of every child node, excluding COMMENT_NODE and
1678 * PROCESSING_INSTRUCTION_NODE nodes</td>
1679 * </tr>
1680 * <tr>
1681 * <td valign='top' rowspan='1' colspan='1'>ATTRIBUTE_NODE, TEXT_NODE,
1682 * CDATA_SECTION_NODE, COMMENT_NODE, PROCESSING_INSTRUCTION_NODE</td>
1683 * <td valign='top' rowspan='1' colspan='1'>
1684 * <code>nodeValue</code></td>
1685 * </tr>
1686 * <tr>
1687 * <td valign='top' rowspan='1' colspan='1'>DOCUMENT_NODE, DOCUMENT_TYPE_NODE, NOTATION_NODE</td>
1688 * <td valign='top' rowspan='1' colspan='1'>
1689 * null</td>
1690 * </tr>
1691 * </table>
1692 * @exception DOMException
1693 * NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
1694 * @exception DOMException
1695 * DOMSTRING_SIZE_ERR: Raised when it would return more characters than
1696 * fit in a <code>DOMString</code> variable on the implementation
1697 * platform.
1698 * @since DOM Level 3
1699 */
1700 public String getTextContent() throws DOMException {
1701 return getNodeValue(); // overriden in some subclasses
1702 }
1703
1704 /**
1705 * Compares a node with this node with regard to their position in the
1706 * document.
1707 * @param other The node to compare against this node.
1708 * @return Returns how the given node is positioned relatively to this
1709 * node.
1710 * @since DOM Level 3
1711 */
1712 public short compareDocumentPosition(Node other) throws DOMException {
1713 return 0;
1714 }
1715
1716 /**
1717 * The absolute base URI of this node or <code>null</code> if undefined.
1718 * This value is computed according to . However, when the
1719 * <code>Document</code> supports the feature "HTML" , the base URI is
1720 * computed using first the value of the href attribute of the HTML BASE
1721 * element if any, and the value of the <code>documentURI</code>
1722 * attribute from the <code>Document</code> interface otherwise.
1723 * <br> When the node is an <code>Element</code>, a <code>Document</code>
1724 * or a a <code>ProcessingInstruction</code>, this attribute represents
1725 * the properties [base URI] defined in . When the node is a
1726 * <code>Notation</code>, an <code>Entity</code>, or an
1727 * <code>EntityReference</code>, this attribute represents the
1728 * properties [declaration base URI] in the . How will this be affected
1729 * by resolution of relative namespace URIs issue?It's not.Should this
1730 * only be on Document, Element, ProcessingInstruction, Entity, and
1731 * Notation nodes, according to the infoset? If not, what is it equal to
1732 * on other nodes? Null? An empty string? I think it should be the
1733 * parent's.No.Should this be read-only and computed or and actual
1734 * read-write attribute?Read-only and computed (F2F 19 Jun 2000 and
1735 * teleconference 30 May 2001).If the base HTML element is not yet
1736 * attached to a document, does the insert change the Document.baseURI?
1737 * Yes. (F2F 26 Sep 2001)
1738 * @since DOM Level 3
1739 */
1740 public String getBaseURI() {
1741 return null;
1742 }
1743
1744 /**
1745 * DOM Level 3
1746 * Renaming node
1747 */
1748 public Node renameNode(Node n,
1749 String namespaceURI,
1750 String name)
1751 throws DOMException{
1752 return n;
1753 }
1754
1755 /**
1756 * DOM Level 3
1757 * Normalize document.
1758 */
1759 public void normalizeDocument(){
1760
1761 }
1762
1763 /**
1764 * The configuration used when <code>Document.normalizeDocument</code> is
1765 * invoked.
1766 * @since DOM Level 3
1767 */
1768 public DOMConfiguration getDomConfig(){
1769 return null;
1770 }
1771
1772
1773 /** DOM Level 3 feature: documentURI */
1774 protected String fDocumentURI;
1775
1776 /**
1777 * DOM Level 3
1778 */
1779 public void setDocumentURI(String documentURI){
1780
1781 fDocumentURI= documentURI;
1782 }
1783
1784 /**
1785 * DOM Level 3
1786 * The location of the document or <code>null</code> if undefined.
1787 * <br>Beware that when the <code>Document</code> supports the feature
1788 * "HTML" , the href attribute of the HTML BASE element takes precedence
1789 * over this attribute.
1790 * @since DOM Level 3
1791 */
1792 public String getDocumentURI(){
1793 return fDocumentURI;
1794 }
1795
1796 /** DOM Level 3 feature: Document actualEncoding */
1797 protected String actualEncoding;
1798
1799 /**
1800 * DOM Level 3
1801 * An attribute specifying the actual encoding of this document. This is
1802 * <code>null</code> otherwise.
1803 * <br> This attribute represents the property [character encoding scheme]
1804 * defined in .
1805 * @since DOM Level 3
1806 */
1807 public String getActualEncoding() {
1808 return actualEncoding;
1809 }
1810
1811 /**
1812 * DOM Level 3
1813 * An attribute specifying the actual encoding of this document. This is
1814 * <code>null</code> otherwise.
1815 * <br> This attribute represents the property [character encoding scheme]
1816 * defined in .
1817 * @since DOM Level 3
1818 */
1819 public void setActualEncoding(String value) {
1820 actualEncoding = value;
1821 }
1822
1823 /**
1824 * DOM Level 3
1825 */
1826 public Text replaceWholeText(String content)
1827 throws DOMException{
1828 /*
1829
1830 if (needsSyncData()) {
1831 synchronizeData();
1832 }
1833
1834 // make sure we can make the replacement
1835 if (!canModify(nextSibling)) {
1836 throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR,
1837 DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "NO_MODIFICATION_ALLOWED_ERR", null));
1838 }
1839
1840 Node parent = this.getParentNode();
1841 if (content == null || content.length() == 0) {
1842 // remove current node
1843 if (parent !=null) { // check if node in the tree
1844 parent.removeChild(this);
1845 return null;
1846 }
1847 }
1848 Text currentNode = null;
1849 if (isReadOnly()){
1850 Text newNode = this.ownerDocument().createTextNode(content);
1851 if (parent !=null) { // check if node in the tree
1852 parent.insertBefore(newNode, this);
1853 parent.removeChild(this);
1854 currentNode = newNode;
1855 } else {
1856 return newNode;
1857 }
1858 } else {
1859 this.setData(content);
1860 currentNode = this;
1861 }
1862 Node sibling = currentNode.getNextSibling();
1863 while ( sibling !=null) {
1864 parent.removeChild(sibling);
1865 sibling = currentNode.getNextSibling();
1866 }
1867
1868 return currentNode;
1869 */
1870 return null; //Pending
1871 }
1872
1873 /**
1874 * DOM Level 3
1875 * Returns all text of <code>Text</code> nodes logically-adjacent text
1876 * nodes to this node, concatenated in document order.
1877 * @since DOM Level 3
1878 */
1879 public String getWholeText(){
1880
1881 /*
1882 if (needsSyncData()) {
1883 synchronizeData();
1884 }
1885 if (nextSibling == null) {
1886 return data;
1887 }
1888 StringBuffer buffer = new StringBuffer();
1889 if (data != null && data.length() != 0) {
1890 buffer.append(data);
1891 }
1892 getWholeText(nextSibling, buffer);
1893 return buffer.toString();
1894 */
1895 return null; // PENDING
1896
1897 }
1898
1899 /**
1900 * DOM Level 3
1901 * Returns whether this text node contains whitespace in element content,
1902 * often abusively called "ignorable whitespace".
1903 */
1904 public boolean isWhitespaceInElementContent(){
1905 return false;
1906 }
1907
1908 /**
1909 * NON-DOM: set the type of this attribute to be ID type.
1910 *
1911 * @param id
1912 */
1913 public void setIdAttribute(boolean id){
1914 //PENDING
1915 }
1916
1917 /**
1918 * DOM Level 3: register the given attribute node as an ID attribute
1919 */
1920 public void setIdAttribute(String name, boolean makeId) {
1921 //PENDING
1922 }
1923
1924 /**
1925 * DOM Level 3: register the given attribute node as an ID attribute
1926 */
1927 public void setIdAttributeNode(Attr at, boolean makeId) {
1928 //PENDING
1929 }
1930
1931 /**
1932 * DOM Level 3: register the given attribute node as an ID attribute
1933 */
1934 public void setIdAttributeNS(String namespaceURI, String localName,
1935 boolean makeId) {
1936 //PENDING
1937 }
1938
1939 /**
1940 * Method getSchemaTypeInfo.
1941 * @return TypeInfo
1942 */
1943 public TypeInfo getSchemaTypeInfo(){
1944 return null; //PENDING
1945 }
1946
1947 public boolean isId() {
1948 return false; //PENDING
1949 }
1950
1951 private String xmlEncoding;
1952 public String getXmlEncoding ( ) {
1953 return xmlEncoding;
1954 }
1955 public void setXmlEncoding ( String xmlEncoding ) {
1956 this.xmlEncoding = xmlEncoding;
1957 }
1958
1959 private boolean xmlStandalone;
1960 public boolean getXmlStandalone() {
1961 return xmlStandalone;
1962 }
1963
1964 public void setXmlStandalone(boolean xmlStandalone) throws DOMException {
1965 this.xmlStandalone = xmlStandalone;
1966 }
1967
1968 private String xmlVersion;
1969 public String getXmlVersion() {
1970 return xmlVersion;
1971 }
1972
1973 public void setXmlVersion(String xmlVersion) throws DOMException {
1974 this.xmlVersion = xmlVersion;
1975 }
1976
1977 }