Java > Open Source Codes > org > enhydra > xml > NodeImpl


1 /*
2  * @(#)NodeImpl.java 1.36 02/03/21
3  *
4  * Copyright 2002 Sun Microsystems, Inc. All rights reserved.
5  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
6  */
7 package org.enhydra.xml;
8
9 import org.w3c.dom.DOMException ;
10 import org.w3c.dom.Document ;
11 import org.w3c.dom.NamedNodeMap ;
12 import org.w3c.dom.Node ;
13 import org.w3c.dom.NodeList ;
14 import org.w3c.dom.UserDataHandler ;
15
16 /**
17  * @author Tweety
18  *
19  * A class representing a node in a meta-data tree, which implements
20  * the <a HREF="../../../../api/org/w3c/dom/Node.html">
21  *
22  * <p> Namespaces are ignored in this implementation. The terms "tag
23  * name" and "node name" are always considered to be synonymous.
24  *
25  * @version 1.0
26  */
27 public class NodeImpl implements Node , NodeList {
28
29     /**
30      * Owner document.
31      */
32     protected Document ownerDocument;
33
34
35     /**
36      * The name (tag) of the node as a <code>String</code>.
37      */
38     protected String nodeName = null;
39
40
41     /**
42      * The value of the node as a <code>String</code>.
43      */
44     protected String nodeValue = null;
45
46
47     /**
48      * The type of the node as a <code>short</code>.
49      */
50     protected short type = ELEMENT_NODE;
51
52
53     /**
54      * The parent node of this node, or <code>null</code> if this node
55      * forms the root of its own tree.
56      */
57     protected NodeImpl parent = null;
58
59
60     /**
61      * The number of child nodes.
62      */
63     protected int numChildren = 0;
64
65
66     /**
67      * The first (leftmost) child node of this node, or
68      * <code>null</code> if this node is a leaf node.
69      */
70     protected NodeImpl firstChild = null;
71
72
73     /**
74      * The last (rightmost) child node of this node, or
75      * <code>null</code> if this node is a leaf node.
76      */
77     protected NodeImpl lastChild = null;
78
79
80     /**
81      * The next (right) sibling node of this node, or
82      * <code>null</code> if this node is its parent's last child node.
83      */
84     protected NodeImpl nextSibling = null;
85
86
87     /**
88      * The previous (left) sibling node of this node, or
89      * <code>null</code> if this node is its parent's first child node.
90      */
91     protected NodeImpl previousSibling = null;
92
93
94     /**
95      * Constructs an empty <code>NodeImpl</code>.
96      */
97     public NodeImpl() {
98     }
99
100
101     /**
102      * Constructs a <code>NodeImpl</code> from the given node,
103      * without creating entire children subtree.
104      *
105      * @param node, as a <code>NodeImpl</code>.
106      */
107     public NodeImpl(NodeImpl node) {
108         ownerDocument = node.ownerDocument;
109         nodeName = node.nodeName;
110         nodeValue = node.nodeValue;
111         type = node.type;
112         parent = node.parent;
113         numChildren = node.numChildren;
114         firstChild = node.firstChild;
115         lastChild = node.lastChild;
116         nextSibling = node.nextSibling;
117         previousSibling = node.previousSibling;
118     }
119
120
121     /**
122      * Constructs an <code>NodeImpl</code> from a given node (creates the children subtree too),
123      * as a <code>Node</code>
124      *
125      * @param node, as a <code>Node</code>.
126      */
127     public NodeImpl(Node node) {
128         this(node, true);
129     }
130
131
132     /**
133      * Constructs an <code>NodeImpl</code> from a given node, as a <code>Node</code>,
134      * and deep as <code>boolean</code>.
135      *
136      * @param node, as a <code>Node</code>.
137      * @param deep if <code>true</code>, recursively clone the subtree
138      * under the specified node; if <code>false</code>, clone only the
139      * node itself.
140      */
141     public NodeImpl(Node node, boolean deep) {
142         this.ownerDocument = node.getOwnerDocument();
143         this.nodeName = node.getNodeName();
144         this.type = node.getNodeType();
145         this.nodeValue = node.getNodeValue();
146         if (deep)
147             this.initNodeImplChildren(node);
148     }
149
150
151     /**
152      * Constructs a <code>NodeImpl</code> from the given document owner and node name.
153      *
154      * @param ownerDoc the document owner of the node, as a <code>Document</code>.
155      * @param name the name of the node, as a <code>String</code>.
156      */
157     public NodeImpl(Document ownerDoc, String name) {
158         this.ownerDocument = ownerDoc;
159         this.nodeName = nodeName;
160     }
161
162
163     /**
164      * Constructs an <code>NodeImpl</code> from a given document owner,
165      * node name and node type.
166      *
167      * @param ownerDoc the document owner of the node, as a <code>Document</code>.
168      * @param nodeName the name of the node, as a <code>String</code>.
169      * @param type the type of the node, as a <code>short</code>.
170      */
171     public NodeImpl(Document ownerDoc, String nodeName, short type) {
172         this.ownerDocument = ownerDoc;
173         this.nodeName = nodeName;
174         this.type = type;
175     }
176
177
178     /**
179      * Constructs an <code>NodeImpl</code> from a given document owner,
180      * node name, node type and node value.
181      *
182      * @param ownerDoc the document owner of the node, as a <code>Document</code>.
183      * @param nodeName the name of the node, as a <code>String</code>.
184      * @param type the type of the node, as a <code>short</code>.
185      * @param value the value of the node, as a <code>String</code>.
186      */
187     public NodeImpl(Document ownerDoc, String nodeName, short type, String value) {
188         this.ownerDocument = ownerDoc;
189         this.nodeName = nodeName;
190         this.type = type;
191         this.nodeValue = value;
192     }
193
194
195
196     /**
197      * Creates the children subtree and adds to this node.
198      * (this part had to be splited from the constructor)
199      *
200      * @param nodeas a <code>Node</code>.
201      */
202     protected void initNodeImplChildren(Node node) {
203         // add children
204 Node child = node.getFirstChild();
205         while (child != null) {
206             switch (child.getNodeType()) {
207                 case Node.ELEMENT_NODE : {
208                     this.appendChild(newElementInstance(child));
209                 }; break;
210                 case Node.TEXT_NODE : {
211                     this.appendChild(newTextInstance(child));
212                 }; break;
213                 case Node.COMMENT_NODE : {
214                     this.appendChild(newCommentInstance(child));
215                 }; break;
216                 default : {
217                     this.appendChild(newDefaultInstance(child));
218                 };
219             }
220             child = child.getNextSibling();
221         }
222     }
223
224
225     /**
226      * Creates new instance of the ElementImpl class.
227      *
228      * @param node, as a <code>Node</code>.
229      * @return Node new instance of the ElementImpl class.
230      */
231     protected Node newElementInstance(Node node) {
232         return new ElementImpl(node);
233     }
234
235     /**
236      * Creates new instance of the TextImpl class.
237      *
238      * @param node, as a <code>Node</code>.
239      * @return Node new instance of the TextImpl class.
240      */
241     protected Node newTextInstance(Node node) {
242         return new TextImpl(node);
243     }
244
245     /**
246      * Creates new instance of the CommentImpl class.
247      *
248      * @param node, as a <code>Node</code>.
249      * @return Node new instance of the CommentImpl class.
250      */
251     protected Node newCommentInstance(Node node) {
252         return new CommentImpl(node);
253     }
254
255     /**
256      * Creates new instance of the NodeImpl class.
257      *
258      * @param node, as a <code>Node</code>.
259      * @return Node new instance of the NodeImpl class.
260      */
261     protected Node newDefaultInstance(Node node) {
262         return new NodeImpl(node);
263     }
264
265
266     /**
267      * Check that the node is either <code>null</code> or an
268      * <code>NodeImpl</code>.
269      *
270      * @exception DOMException if node is not an instance of <code>NodeImpl</code>.
271      */
272     private void checkNode(Node node) throws DOMException {
273         if (node == null) {
274             return;
275         }
276         if (!(node instanceof NodeImpl))
277             throw new NodeDOMException(DOMException.WRONG_DOCUMENT_ERR, "Node not an NodeImpl!");
278     }
279
280
281
282     // Methods from Node
283
284     /**
285      * Returns the name associated with this node.
286      *
287      * @return the name, as a <code>String</code>.
288      */
289     public String getNodeName() {
290         return nodeName;
291     }
292
293
294     /**
295      * Returns the value associated with this node.
296      *
297      * @return the node value, as a <code>String</code>.
298      */
299     public String getNodeValue() {
300         return nodeValue;
301     }
302
303
304     /**
305      * Sets the node value of this node.
306      *
307      * @param nodeValue new node value, as a <code>String</code>.
308      */
309     public void setNodeValue(String nodeValue) {
310         this.nodeValue = nodeValue;
311     }
312
313
314     /**
315      * Returns the node type.
316      *
317      * @return the <code>short</code> value node type.
318      */
319     public short getNodeType() {
320         return type;
321     }
322
323
324     /**
325      * Returns the parent of this node. A <code>null</code> value
326      * indicates that the node is the root of its own tree. To add a
327      * node to an existing tree, use one of the
328      * <code>insertBefore</code>, <code>replaceChild</code>, or
329      * <code>appendChild</code> methods.
330      *
331      * @return the parent, as a <code>Node</code>.
332      *
333      * @see #insertBefore
334      * @see #replaceChild
335      * @see #appendChild
336      */
337     public Node getParentNode() {
338         return parent;
339     }
340
341
342     /**
343      * Returns all child nodes of this node, or <code>null</code> if
344      * the node has no children.
345      *
346      * @return all child nodes of this node, as a <code>Node</code>, or
347      * <code>null</code>.
348      */
349     public NodeList getChildNodes() {
350         return this;
351     }
352
353
354     /**
355      * Returns the first child of this node, or <code>null</code> if
356      * the node has no children.
357      *
358      * @return the first child, as a <code>Node</code>, or
359      * <code>null</code>
360      */
361     public Node getFirstChild() {
362         return firstChild;
363     }
364
365
366     /**
367      * Returns the last child of this node, or <code>null</code> if
368      * the node has no children.
369      *
370      * @return the last child, as a <code>Node</code>, or
371      * <code>null</code>.
372      */
373     public Node getLastChild() {
374         return lastChild;
375     }
376
377
378     /**
379      * Returns the previous sibling of this node, or <code>null</code>
380      * if this node has no previous sibling.
381      *
382      * @return the previous sibling, as a <code>Node</code>, or
383      * <code>null</code>.
384      */
385     public Node getPreviousSibling() {
386         return previousSibling;
387     }
388
389
390     /**
391      * Returns the next sibling of this node, or <code>null</code> if
392      * the node has no next sibling.
393      *
394      * @return the next sibling, as a <code>Node</code>, or
395      * <code>null</code>.
396      */
397     public Node getNextSibling() {
398         return nextSibling;
399     }
400
401
402     /**
403      * Returns <code>null</code>, since <code>NodeImpl</code>s
404      * do not belong to any <code>Document</code>.
405      *
406      * @return document owner as <code>Document</code>.
407      */
408     public Document getOwnerDocument() {
409         return ownerDocument;
410     }
411
412
413     /**
414      * Inserts the node <code>newChild</code> before the existing
415      * child node <code>refChild</code>. If <code>refChild</code> is
416      * <code>null</code>, insert <code>newChild</code> at the end of
417      * the list of children.
418      *
419      * @param newChild the <code>Node</code> to insert.
420      * @param refChild the reference <code>Node</code>.
421      *
422      * @return the node being inserted.
423      *
424      * @exception IllegalArgumentException if <code>newChild</code> is
425      * <code>null</code>.
426      */
427     public Node insertBefore(Node newChild, Node refChild) {
428         if (newChild == null) {
429             throw new IllegalArgumentException ("newChild == null!");
430         }
431
432         checkNode(newChild);
433         checkNode(refChild);
434
435         NodeImpl newChildNode = (NodeImpl) newChild;
436         NodeImpl refChildNode = (NodeImpl) refChild;
437
438         // Siblings, can be null.
439 NodeImpl previous = null;
440         NodeImpl next = null;
441
442         if (refChild == null) {
443             previous = this.lastChild;
444             next = null;
445             this.lastChild = newChildNode;
446         } else {
447             previous = refChildNode.previousSibling;
448             next = refChildNode;
449         }
450
451         if (previous != null) {
452             previous.nextSibling = newChildNode;
453         }
454         if (next != null) {
455             next.previousSibling = newChildNode;
456         }
457
458         newChildNode.parent = this;
459         newChildNode.previousSibling = previous;
460         newChildNode.nextSibling = next;
461
462         // N.B.: O.K. if refChild == null
463 if (this.firstChild == refChildNode) {
464             this.firstChild = newChildNode;
465         }
466         ++numChildren;
467         return newChildNode;
468     }
469
470
471     /**
472      * Replaces the child node <code>oldChild</code> with
473      * <code>newChild</code> in the list of children, and returns the
474      * <code>oldChild</code> node.
475      *
476      * @param newChild the <code>Node</code> to insert.
477      * @param oldChild the <code>Node</code> to be replaced.
478      *
479      * @return the node replaced.
480      *
481      * @exception IllegalArgumentException if <code>newChild</code> is
482      * <code>null</code>.
483      */
484     public Node replaceChild(Node newChild, Node oldChild) {
485         if (newChild == null) {
486             throw new IllegalArgumentException ("newChild == null!");
487         }
488
489         checkNode(newChild);
490         checkNode(oldChild);
491
492         NodeImpl newChildNode = (NodeImpl) newChild;
493         NodeImpl oldChildNode = (NodeImpl) oldChild;
494
495         NodeImpl previous = oldChildNode.previousSibling;
496         NodeImpl next = oldChildNode.nextSibling;
497
498         if (previous != null) {
499             previous.nextSibling = newChildNode;
500         }
501         if (next != null) {
502             next.previousSibling = newChildNode;
503         }
504
505         newChildNode.parent = this;
506         newChildNode.previousSibling = previous;
507         newChildNode.nextSibling = next;
508
509         if (firstChild == oldChildNode) {
510             firstChild = newChildNode;
511         }
512         if (lastChild == oldChildNode) {
513             lastChild = newChildNode;
514         }
515
516         oldChildNode.parent = null;
517         oldChildNode.previousSibling = null;
518         oldChildNode.nextSibling = null;
519
520         return oldChildNode;
521     }
522
523
524     /**
525      * Removes the child node indicated by <code>oldChild</code> from
526      * the list of children, and returns it.
527      *
528      * @param oldChild the <code>Node</code> to be removed.
529      *
530      * @return the node removed.
531      *
532      * @exception IllegalArgumentException if <code>oldChild</code> is
533      * <code>null</code>.
534      */
535     public Node removeChild(Node oldChild) {
536         if (oldChild == null) {
537             throw new IllegalArgumentException ("oldChild == null!");
538         }
539         checkNode(oldChild);
540
541         NodeImpl oldChildNode = (NodeImpl) oldChild;
542
543         NodeImpl previous = oldChildNode.previousSibling;
544         NodeImpl next = oldChildNode.nextSibling;
545
546         if (previous != null) {
547             previous.nextSibling = next;
548         }
549         if (next != null) {
550             next.previousSibling = previous;
551         }
552
553         if (this.firstChild == oldChildNode) {
554             this.firstChild = next;
555         }
556         if (this.lastChild == oldChildNode) {
557             this.lastChild = previous;
558         }
559
560         oldChildNode.parent = null;
561         oldChildNode.previousSibling = null;
562         oldChildNode.nextSibling = null;
563
564         --numChildren;
565         return oldChildNode;
566     }
567
568
569     /**
570      * Adds the node <code>newChild</code> to the end of the list of
571      * children of this node.
572      *
573      * @param newChild the <code>Node</code> to insert.
574      *
575      * @return the node added.
576      *
577      * @exception IllegalArgumentException if <code>newChild</code> is
578      * <code>null</code>.
579      */
580     public Node appendChild(Node newChild) {
581         if (newChild == null) {
582             throw new IllegalArgumentException ("newChild == null!");
583         }
584         checkNode(newChild);
585
586         // insertBefore will increment numChildren
587 return insertBefore(newChild, null);
588     }
589
590
591     /**
592      * Returns <code>true</code> if this node has child nodes.
593      *
594      * @return <code>true</code> if this node has children.
595      */
596     public boolean hasChildNodes() {
597         return numChildren > 0;
598     }
599
600
601     /**
602      * Returns a duplicate of this node. The duplicate node has no
603      * parent (<code>getParentNode</code> returns <code>null</code>).
604      * If a shallow clone is being performed (<code>deep</code> is
605      * <code>false</code>), the new node will not have any children or
606      * siblings. If a deep clone is being performed, the new node
607      * will form the root of a complete cloned subtree.
608      *
609      * @param deep if <code>true</code>, recursively clone the subtree
610      * under the specified node; if <code>false</code>, clone only the
611      * node itself.
612      *
613      * @return the duplicate node.
614      */
615     public Node cloneNode(boolean deep) {
616         return new NodeImpl(this, deep);
617     }
618
619
620     /**
621      * Does nothing, since <code>NodeImpl</code>s do not
622      * contain <code>Text</code> children.
623      */
624     public void normalize() {
625     }
626
627
628     /**
629      * Returns <code>false</code> since DOM features are not
630      * supported.
631      *
632      * @return <code>false</code>.
633      *
634      * @param feature a <code>String</code>, which is ignored.
635      * @param version a <code>String</code>, which is ignored.
636      */
637     public boolean isSupported(String feature, String version) {
638         return false;
639     }
640
641
642     /**
643      * Returns <code>null</code>, since namespaces are not supported.
644      *
645      * @return <code>null</code>.
646      *
647      * @see #setPrefix
648      */
649     public String getPrefix() {
650         return null;
651     }
652
653
654     /**
655      * Does nothing, since namespaces are not supported.
656      *
657      * @param prefix a <code>String</code>, which is ignored.
658      *
659      * @see #getPrefix
660      */
661     public void setPrefix(String prefix) {
662     }
663
664
665     /**
666      * Equivalent to <code>getNodeName</code>.
667      *
668      * @return the node name, as a <code>String</code>.
669      */
670     public String getLocalName() {
671         return nodeName;
672     }
673
674
675     /**
676      * Returns all attribute nodes of this node.
677      *
678      * @return all attribute nodes of this node.
679      */
680     public NamedNodeMap getAttributes() {
681         return null;
682     }
683
684
685     /**
686      * Returns <code>true</code>, if this node has attributes, otherwise
687      * <code>false</code>.
688      *
689      * @return <code>true</code> if node has attributes, otherwise <code>false</code>..
690      */
691     public boolean hasAttributes() {
692         return false;
693     }
694
695
696
697
698     // Methods from NodeList
699
700
701     /**
702      * Returns number of child nodes.
703      *
704      * @return all number of child nodes.
705      */
706     public int getLength() {
707         return numChildren;
708     }
709
710
711     /**
712      * Returns child node with the given index.
713      *
714      * @return child node with the given index.
715      */
716     public Node item(int index) {
717         if (index < 0) {
718             return null;
719         }
720
721         Node child = getFirstChild();
722         while (child != null && index-- > 0) {
723             child = child.getNextSibling();
724         }
725         return child;
726     }
727
728
729
730     // String methodes
731
732     /**
733      * Returns <code>String</code> representation of this node.
734      *
735      * @return <code>String</code> representation of this node.
736      */
737     public String toString() {
738         return toString(Indent.DEFAULT_TAB);
739     }
740
741
742     /**
743      * Returns <code>String</code> representation of this node.
744      *
745      * @param tab tab for node indentation.
746      *
747      * @return <code>String</code> representation of this node.
748      */
749     public String toString(String tab) {
750         StringBuffer sb = new StringBuffer ();
751         this.allToString(sb, new Indent(0,tab));
752         return sb.toString();
753     }
754
755
756     /**
757      * Method beginToString should be redefined in extended classes.
758      * Each type of node has its own <code>beginToString and
759      * <code>endToString</code>. This was added to support
760      * writing of the xml file. The <code>Element</code>
761      * type of node: it writes the beginning tag, then calls
762      * the child's <code>toString</code>, and then writes the ending tag.
763      *
764      * @param sb string buffer to add resulting string.
765      * @param indent used in formating the output.
766      */
767     protected void beginToString(StringBuffer sb, Indent indent) {
768     }
769
770
771     /**
772      * Method endToString should be redefined in extended classes.
773      * Each type of node has its own <code>beginToString and
774      * <code>endToString</code>. This was added to support
775      * writing of the xml file. The <code>Element</code>
776      * type of node: it writes the beginning tag, then calls
777      * the child's <code>toString</code>, and then writes the ending tag.
778      *
779      * @param sb string buffer to add resulting string.
780      * @param indent used in formating the output.
781      */
782     protected void endToString(StringBuffer sb, Indent indent) {
783     }
784
785
786     private void allToString(StringBuffer sb, Indent indent) {
787         this.beginToString(sb, indent);
788         Node child = getFirstChild();
789         while (child != null) {
790             ((NodeImpl) child).allToString(sb, indent);
791             child = child.getNextSibling();
792         }
793         this.endToString(sb, indent);
794     }
795
796
797     /* (non-Javadoc)
798      * @see org.w3c.dom.Node#getBaseURI()
799      */
800     public String getBaseURI() {
801         // TODO Auto-generated method stub
802 return null;
803     }
804
805
806     /* (non-Javadoc)
807      * @see org.w3c.dom.Node#compareDocumentPosition(org.w3c.dom.Node)
808      */
809     public short compareDocumentPosition(Node arg0) throws DOMException {
810         // TODO Auto-generated method stub
811 return 0;
812     }
813
814
815     /* (non-Javadoc)
816      * @see org.w3c.dom.Node#getTextContent()
817      */
818     public String getTextContent() throws DOMException {
819         // TODO Auto-generated method stub
820 return null;
821     }
822
823
824     /* (non-Javadoc)
825      * @see org.w3c.dom.Node#setTextContent(java.lang.String)
826      */
827     public void setTextContent(String arg0) throws DOMException {
828         // TODO Auto-generated method stub
829
830     }
831
832
833     /* (non-Javadoc)
834      * @see org.w3c.dom.Node#isSameNode(org.w3c.dom.Node)
835      */
836     public boolean isSameNode(Node arg0) {
837         // TODO Auto-generated method stub
838 return false;
839     }
840
841
842     /* (non-Javadoc)
843      * @see org.w3c.dom.Node#lookupPrefix(java.lang.String)
844      */
845     public String lookupPrefix(String arg0) {
846         // TODO Auto-generated method stub
847 return null;
848     }
849
850
851     /* (non-Javadoc)
852      * @see org.w3c.dom.Node#isDefaultNamespace(java.lang.String)
853      */
854     public boolean isDefaultNamespace(String arg0) {
855         // TODO Auto-generated method stub
856 return false;
857     }
858
859
860     /* (non-Javadoc)
861      * @see org.w3c.dom.Node#lookupNamespaceURI(java.lang.String)
862      */
863     public String lookupNamespaceURI(String arg0) {
864         // TODO Auto-generated method stub
865 return null;
866     }
867
868
869     /* (non-Javadoc)
870      * @see org.w3c.dom.Node#isEqualNode(org.w3c.dom.Node)
871      */
872     public boolean isEqualNode(Node arg0) {
873         // TODO Auto-generated method stub
874 return false;
875     }
876
877
878     /* (non-Javadoc)
879      * @see org.w3c.dom.Node#getFeature(java.lang.String, java.lang.String)
880      */
881     public Object getFeature(String arg0, String arg1) {
882         // TODO Auto-generated method stub
883 return null;
884     }
885
886
887     /* (non-Javadoc)
888      * @see org.w3c.dom.Node#setUserData(java.lang.String, java.lang.Object, org.w3c.dom.UserDataHandler)
889      */
890     public Object setUserData(String arg0, Object arg1, UserDataHandler arg2) {
891         // TODO Auto-generated method stub
892 return null;
893     }
894
895
896     /* (non-Javadoc)
897      * @see org.w3c.dom.Node#getUserData(java.lang.String)
898      */
899     public Object getUserData(String arg0) {
900         // TODO Auto-generated method stub
901 return null;
902     }
903
904
905     /* (non-Javadoc)
906      * @see org.w3c.dom.Node#getNamespaceURI()
907      */
908     public String getNamespaceURI() {
909         // TODO Auto-generated method stub
910 return null;
911     }
912
913 }
914
915
916
917

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags