Classes in this File | Line Coverage | Branch Coverage | Complexity | ||||||||
NamespaceNode |
|
| 1.565217391304348;1.565 |
1 | /* |
|
2 | * $Header: /home/projects/jaxen/scm/jaxen/src/java/main/org/jaxen/dom/NamespaceNode.java,v 1.20 2005/06/28 13:44:46 elharo Exp $ |
|
3 | * $Revision: 1.20 $ |
|
4 | * $Date: 2005/06/28 13:44:46 $ |
|
5 | * |
|
6 | * ==================================================================== |
|
7 | * |
|
8 | * Copyright (C) 2000-2002 bob mcwhirter & James Strachan. |
|
9 | * All rights reserved. |
|
10 | * |
|
11 | * Redistribution and use in source and binary forms, with or without |
|
12 | * modification, are permitted provided that the following conditions |
|
13 | * are met: |
|
14 | * |
|
15 | * 1. Redistributions of source code must retain the above copyright |
|
16 | * notice, this list of conditions, and the following disclaimer. |
|
17 | * |
|
18 | * 2. Redistributions in binary form must reproduce the above copyright |
|
19 | * notice, this list of conditions, and the disclaimer that follows |
|
20 | * these conditions in the documentation and/or other materials |
|
21 | * provided with the distribution. |
|
22 | * |
|
23 | * 3. The name "Jaxen" must not be used to endorse or promote products |
|
24 | * derived from this software without prior written permission. For |
|
25 | * written permission, please contact license@jaxen.org. |
|
26 | * |
|
27 | * 4. Products derived from this software may not be called "Jaxen", nor |
|
28 | * may "Jaxen" appear in their name, without prior written permission |
|
29 | * from the Jaxen Project Management (pm@jaxen.org). |
|
30 | * |
|
31 | * In addition, we request (but do not require) that you include in the |
|
32 | * end-user documentation provided with the redistribution and/or in the |
|
33 | * software itself an acknowledgement equivalent to the following: |
|
34 | * "This product includes software developed by the |
|
35 | * Jaxen Project <http://www.jaxen.org/>." |
|
36 | * Alternatively, the acknowledgment may be graphical using the logos |
|
37 | * available at http://www.jaxen.org/ |
|
38 | * |
|
39 | * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED |
|
40 | * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
|
41 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|
42 | * DISCLAIMED. IN NO EVENT SHALL THE Jaxen AUTHORS OR THE PROJECT |
|
43 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|
44 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
|
45 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF |
|
46 | * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
|
47 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
|
48 | * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT |
|
49 | * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|
50 | * SUCH DAMAGE. |
|
51 | * |
|
52 | * ==================================================================== |
|
53 | * This software consists of voluntary contributions made by many |
|
54 | * individuals on behalf of the Jaxen Project and was originally |
|
55 | * created by bob mcwhirter <bob@werken.com> and |
|
56 | * James Strachan <jstrachan@apache.org>. For more information on the |
|
57 | * Jaxen Project, please see <http://www.jaxen.org/>. |
|
58 | * |
|
59 | * $Id: NamespaceNode.java,v 1.20 2005/06/28 13:44:46 elharo Exp $ |
|
60 | */ |
|
61 | ||
62 | //////////////////////////////////////////////////////////////////// |
|
63 | // Inner class for a Namespace node. |
|
64 | //////////////////////////////////////////////////////////////////// |
|
65 | ||
66 | package org.jaxen.dom; |
|
67 | ||
68 | import java.util.HashMap; |
|
69 | ||
70 | import org.jaxen.pattern.Pattern; |
|
71 | import org.w3c.dom.DOMException; |
|
72 | import org.w3c.dom.Document; |
|
73 | import org.w3c.dom.NamedNodeMap; |
|
74 | import org.w3c.dom.Node; |
|
75 | import org.w3c.dom.NodeList; |
|
76 | import org.w3c.dom.UserDataHandler; |
|
77 | ||
78 | ||
79 | /** |
|
80 | * Extension DOM2/DOm3 node type for a namespace node. |
|
81 | * |
|
82 | * <p>This class implements the DOM2 and DOM3 {@link Node} interface |
|
83 | * to allow namespace nodes to be included in the result |
|
84 | * set of an XPath selectNodes operation, even though DOM does |
|
85 | * not model namespaces in scope as separate nodes.</p> |
|
86 | * |
|
87 | * <p> |
|
88 | * While all of the DOM2 methods are implemented with reasonable |
|
89 | * defaults, there will be some unexpected surprises, so users are |
|
90 | * advised to test for NamespaceNodes and filter them out from the |
|
91 | * result sets as early as possible. |
|
92 | * </p> |
|
93 | * |
|
94 | * <ol> |
|
95 | * |
|
96 | * <li>The {@link #getNodeType} method returns {@link #NAMESPACE_NODE}, |
|
97 | * which is not one of the usual DOM2 node types. Generic code may |
|
98 | * fall unexpectedly out of switch statements, for example.</li> |
|
99 | * |
|
100 | * <li>The {@link #getOwnerDocument} method returns the owner document |
|
101 | * of the parent node, but that owner document will know nothing about |
|
102 | * the namespace node.</p> |
|
103 | * |
|
104 | * <li>The {@link #isSupported} method always returns false.</li> |
|
105 | * |
|
106 | * <li> The DOM3 methods sometimes throw UnsupportedOperationException. |
|
107 | * They're here only to allow this class to be compiled with Java 1.5. |
|
108 | * Do not call or rely on them.</li> |
|
109 | * </ol> |
|
110 | * |
|
111 | * <p>All attempts to modify a <code>NamespaceNode</code> will fail with a {@link |
|
112 | * DOMException} ({@link |
|
113 | * DOMException#NO_MODIFICATION_ALLOWED_ERR}).</p> |
|
114 | * |
|
115 | * @author David Megginson |
|
116 | * @author Elliotte Rusty Harold |
|
117 | * @see DocumentNavigator |
|
118 | */ |
|
119 | public class NamespaceNode implements Node |
|
120 | { |
|
121 | ||
122 | ||
123 | //////////////////////////////////////////////////////////////////// |
|
124 | // Constants. |
|
125 | //////////////////////////////////////////////////////////////////// |
|
126 | ||
127 | /** |
|
128 | * Constant: this is a NamespaceNode. |
|
129 | * |
|
130 | * @see #getNodeType |
|
131 | */ |
|
132 | public final static short NAMESPACE_NODE = Pattern.NAMESPACE_NODE; |
|
133 | ||
134 | // FIXME "Note: Numeric codes up to 200 are reserved to W3C for possible future use." |
|
135 | // Ww should be using higher codes. |
|
136 | ||
137 | //////////////////////////////////////////////////////////////////// |
|
138 | // Protected Constructors. |
|
139 | //////////////////////////////////////////////////////////////////// |
|
140 | ||
141 | ||
142 | /** |
|
143 | * Create a new NamespaceNode. |
|
144 | * |
|
145 | * @param parent the DOM node to which the namespace is attached |
|
146 | * @param name the namespace prefix |
|
147 | * @param value the namespace URI |
|
148 | */ |
|
149 | public NamespaceNode (Node parent, String name, String value) |
|
150 | 768 | { |
151 | 768 | this.parent = parent; |
152 | 768 | this.name = name; |
153 | 768 | this.value = value; |
154 | 768 | } |
155 | ||
156 | ||
157 | /** |
|
158 | * Constructor. |
|
159 | * |
|
160 | * @param parent the DOM node to which the namespace is attached |
|
161 | * @param attribute the DOM attribute object containing the |
|
162 | * namespace declaration |
|
163 | */ |
|
164 | NamespaceNode (Node parent, Node attribute) |
|
165 | 582 | { |
166 | 582 | String attributeName = attribute.getNodeName(); |
167 | ||
168 | 582 | if (attributeName.equals("xmlns")) { |
169 | 0 | this.name = ""; |
170 | } |
|
171 | 582 | else if (attributeName.startsWith("xmlns:")) { |
172 | 582 | this.name = attributeName.substring(6); // the part after "xmlns:" |
173 | } |
|
174 | else { // workaround for Crimson bug; Crimson incorrectly reports the prefix as the node name |
|
175 | 0 | this.name = attributeName; |
176 | } |
|
177 | 582 | this.parent = parent; |
178 | 582 | this.value = attribute.getNodeValue(); |
179 | 582 | } |
180 | ||
181 | ||
182 | ||
183 | //////////////////////////////////////////////////////////////////// |
|
184 | // Implementation of org.w3c.dom.Node. |
|
185 | //////////////////////////////////////////////////////////////////// |
|
186 | ||
187 | ||
188 | /** |
|
189 | * Get the namespace prefix. |
|
190 | * |
|
191 | * @return the namespace prefix, or "" for the default namespace |
|
192 | */ |
|
193 | public String getNodeName () |
|
194 | { |
|
195 | 606 | return name; |
196 | } |
|
197 | ||
198 | ||
199 | /** |
|
200 | * Get the namespace URI. |
|
201 | * |
|
202 | * @return the namespace URI |
|
203 | */ |
|
204 | public String getNodeValue () |
|
205 | { |
|
206 | 66 | return value; |
207 | } |
|
208 | ||
209 | ||
210 | /** |
|
211 | * Change the namespace URI (always fails). |
|
212 | * |
|
213 | * @param value the new URI |
|
214 | * @throws DOMException always |
|
215 | */ |
|
216 | public void setNodeValue (String value) throws DOMException |
|
217 | { |
|
218 | 0 | disallowModification(); |
219 | 0 | } |
220 | ||
221 | ||
222 | /** |
|
223 | * Get the node type. |
|
224 | * |
|
225 | * @return always {@link #NAMESPACE_NODE}. |
|
226 | */ |
|
227 | public short getNodeType () |
|
228 | { |
|
229 | 9276 | return NAMESPACE_NODE; |
230 | } |
|
231 | ||
232 | ||
233 | /** |
|
234 | * Get the parent node. |
|
235 | * |
|
236 | * <p>This method returns the element that was queried for Namespaces |
|
237 | * in effect, <em>not</em> necessarily the actual element containing |
|
238 | * the Namespace declaration.</p> |
|
239 | * |
|
240 | * @return the parent node (not null) |
|
241 | */ |
|
242 | public Node getParentNode () |
|
243 | { |
|
244 | 2238 | return parent; |
245 | } |
|
246 | ||
247 | ||
248 | /** |
|
249 | * Get the list of child nodes. |
|
250 | * |
|
251 | * @return an empty node list |
|
252 | */ |
|
253 | public NodeList getChildNodes () |
|
254 | { |
|
255 | 0 | return new EmptyNodeList(); |
256 | } |
|
257 | ||
258 | ||
259 | /** |
|
260 | * Get the first child node. |
|
261 | * |
|
262 | * @return null |
|
263 | */ |
|
264 | public Node getFirstChild () |
|
265 | { |
|
266 | 0 | return null; |
267 | } |
|
268 | ||
269 | ||
270 | /** |
|
271 | * Get the last child node. |
|
272 | * |
|
273 | * @return null |
|
274 | */ |
|
275 | public Node getLastChild () |
|
276 | { |
|
277 | 0 | return null; |
278 | } |
|
279 | ||
280 | ||
281 | /** |
|
282 | * Get the previous sibling node. |
|
283 | * |
|
284 | * @return null |
|
285 | */ |
|
286 | public Node getPreviousSibling () |
|
287 | { |
|
288 | 0 | return null; |
289 | } |
|
290 | ||
291 | ||
292 | /** |
|
293 | * Get the next sibling node. |
|
294 | * |
|
295 | * @return null |
|
296 | */ |
|
297 | public Node getNextSibling () |
|
298 | { |
|
299 | 0 | return null; |
300 | } |
|
301 | ||
302 | ||
303 | /** |
|
304 | * Get the attribute nodes. |
|
305 | * |
|
306 | * @return null |
|
307 | */ |
|
308 | public NamedNodeMap getAttributes () |
|
309 | { |
|
310 | 0 | return null; |
311 | } |
|
312 | ||
313 | ||
314 | /** |
|
315 | * Get the owner document. |
|
316 | * |
|
317 | * @return the owner document <em>of the parent node</em> |
|
318 | */ |
|
319 | public Document getOwnerDocument () |
|
320 | { |
|
321 | 0 | if (parent == null) return null; |
322 | 0 | return parent.getOwnerDocument(); |
323 | } |
|
324 | ||
325 | ||
326 | /** |
|
327 | * Insert a new child node (always fails). |
|
328 | * |
|
329 | * @param newChild the node to add |
|
330 | * @param refChild ignored |
|
331 | * @return never |
|
332 | * @throws DOMException always |
|
333 | * @see Node#insertBefore |
|
334 | */ |
|
335 | public Node insertBefore (Node newChild, Node refChild) |
|
336 | throws DOMException |
|
337 | { |
|
338 | 0 | disallowModification(); |
339 | 0 | return null; |
340 | } |
|
341 | ||
342 | ||
343 | /** |
|
344 | * Replace a child node (always fails). |
|
345 | * |
|
346 | * @param newChild the node to add |
|
347 | * @param oldChild the child node to replace |
|
348 | * @return never |
|
349 | * @throws DOMException always |
|
350 | * @see Node#replaceChild |
|
351 | */ |
|
352 | public Node replaceChild (Node newChild, Node oldChild) |
|
353 | throws DOMException |
|
354 | { |
|
355 | 0 | disallowModification(); |
356 | 0 | return null; |
357 | } |
|
358 | ||
359 | ||
360 | /** |
|
361 | * Remove a child node (always fails). |
|
362 | * |
|
363 | * @param oldChild the child node to remove |
|
364 | * @return never |
|
365 | * @throws DOMException always |
|
366 | * @see Node#removeChild |
|
367 | */ |
|
368 | public Node removeChild (Node oldChild) |
|
369 | throws DOMException |
|
370 | { |
|
371 | 0 | disallowModification(); |
372 | 0 | return null; |
373 | } |
|
374 | ||
375 | ||
376 | /** |
|
377 | * Append a new child node (always fails). |
|
378 | * |
|
379 | * @param newChild the node to add |
|
380 | * @return never |
|
381 | * @throws DOMException always |
|
382 | * @see Node#appendChild |
|
383 | */ |
|
384 | public Node appendChild (Node newChild) |
|
385 | throws DOMException |
|
386 | { |
|
387 | 0 | disallowModification(); |
388 | 0 | return null; |
389 | } |
|
390 | ||
391 | ||
392 | /** |
|
393 | * Test for child nodes. |
|
394 | * |
|
395 | * @return false |
|
396 | */ |
|
397 | public boolean hasChildNodes () |
|
398 | { |
|
399 | 0 | return false; |
400 | } |
|
401 | ||
402 | ||
403 | /** |
|
404 | * Create a copy of this node. |
|
405 | * |
|
406 | * @param deep make a deep copy (no effect, since namespace nodes |
|
407 | * don't have children). |
|
408 | * @return a new copy of this namespace node |
|
409 | */ |
|
410 | public Node cloneNode (boolean deep) |
|
411 | { |
|
412 | 0 | return new NamespaceNode(parent, name, value); |
413 | } |
|
414 | ||
415 | ||
416 | /** |
|
417 | * Normalize the text descendants of this node. |
|
418 | * |
|
419 | * <p>This method has no effect, since namespace nodes have no |
|
420 | * descendants.</p> |
|
421 | */ |
|
422 | public void normalize () |
|
423 | { |
|
424 | // no op |
|
425 | 0 | } |
426 | ||
427 | ||
428 | /** |
|
429 | * Test if a DOM2 feature is supported. |
|
430 | * |
|
431 | * @param feature the feature name |
|
432 | * @param version the feature version |
|
433 | * @return false |
|
434 | */ |
|
435 | public boolean isSupported (String feature, String version) |
|
436 | { |
|
437 | 0 | return false; |
438 | } |
|
439 | ||
440 | ||
441 | /** |
|
442 | * Get the namespace URI of this node. |
|
443 | * |
|
444 | * <p>Namespace declarations are not themselves |
|
445 | * Namespace-qualified.</p> |
|
446 | * |
|
447 | * @return null |
|
448 | */ |
|
449 | public String getNamespaceURI () |
|
450 | { |
|
451 | 0 | return null; |
452 | } |
|
453 | ||
454 | ||
455 | /** |
|
456 | * Get the namespace prefix of this node. |
|
457 | * |
|
458 | * <p>Namespace declarations are not themselves |
|
459 | * namespace-qualified.</p> |
|
460 | * |
|
461 | * @return null |
|
462 | * @see #getLocalName |
|
463 | */ |
|
464 | public String getPrefix () |
|
465 | { |
|
466 | 0 | return null; |
467 | } |
|
468 | ||
469 | ||
470 | /** |
|
471 | * Change the namespace prefix of this node (always fails). |
|
472 | * |
|
473 | * @param prefix the new prefix |
|
474 | * @throws DOMException always thrown |
|
475 | */ |
|
476 | public void setPrefix (String prefix) |
|
477 | throws DOMException |
|
478 | { |
|
479 | 0 | disallowModification(); |
480 | 0 | } |
481 | ||
482 | ||
483 | /** |
|
484 | * Get the XPath name of the namespace node;; i.e. the |
|
485 | * namespace prefix. |
|
486 | * |
|
487 | * @return the namespace prefix |
|
488 | */ |
|
489 | public String getLocalName () |
|
490 | { |
|
491 | 942 | return name; |
492 | } |
|
493 | ||
494 | ||
495 | /** |
|
496 | * Test if this node has attributes. |
|
497 | * |
|
498 | * @return false |
|
499 | */ |
|
500 | public boolean hasAttributes () |
|
501 | { |
|
502 | 0 | return false; |
503 | } |
|
504 | ||
505 | ||
506 | /** |
|
507 | * Throw a NO_MODIFICATION_ALLOWED_ERR DOMException. |
|
508 | * |
|
509 | * @throws DOMException always thrown |
|
510 | */ |
|
511 | private void disallowModification () throws DOMException |
|
512 | { |
|
513 | 6 | throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR, |
514 | "Namespace node may not be modified"); |
|
515 | } |
|
516 | ||
517 | ||
518 | ||
519 | //////////////////////////////////////////////////////////////////// |
|
520 | // Override default methods from java.lang.Object. |
|
521 | //////////////////////////////////////////////////////////////////// |
|
522 | ||
523 | ||
524 | /** |
|
525 | * Generate a hash code for a namespace node. |
|
526 | * |
|
527 | * @return a hash code for this node |
|
528 | */ |
|
529 | public int hashCode () |
|
530 | { |
|
531 | 48 | return hashCode(parent) + hashCode(name) + hashCode(value); |
532 | } |
|
533 | ||
534 | ||
535 | /** |
|
536 | * Test for equivalence with another object. |
|
537 | * |
|
538 | * <p>Two Namespace nodes are considered equivalent if their parents, |
|
539 | * names, and values are equal.</p> |
|
540 | * |
|
541 | * @param o the object to test for equality |
|
542 | * @return true if the object is equivalent to this node, false |
|
543 | * otherwise |
|
544 | */ |
|
545 | public boolean equals (Object o) |
|
546 | { |
|
547 | 0 | if (o == this) return true; |
548 | 0 | else if (o == null) return false; |
549 | 0 | else if (o instanceof NamespaceNode) { |
550 | 0 | NamespaceNode ns = (NamespaceNode)o; |
551 | 0 | return (equals(parent, ns.getParentNode()) && |
552 | equals(name, ns.getNodeName()) && |
|
553 | equals(value, ns.getNodeValue())); |
|
554 | } else { |
|
555 | 0 | return false; |
556 | } |
|
557 | } |
|
558 | ||
559 | ||
560 | /** |
|
561 | * Helper method for generating a hash code. |
|
562 | * |
|
563 | * @param o the object for generating a hash code (possibly null) |
|
564 | * @return the object's hash code, or 0 if the object is null |
|
565 | * @see java.lang.Object#hashCode |
|
566 | */ |
|
567 | private int hashCode (Object o) |
|
568 | { |
|
569 | 144 | return (o == null ? 0 : o.hashCode()); |
570 | } |
|
571 | ||
572 | ||
573 | /** |
|
574 | * Helper method for comparing two objects. |
|
575 | * |
|
576 | * @param a the first object to compare (possibly null) |
|
577 | * @param b the second object to compare (possibly null) |
|
578 | * @return true if the objects are equivalent or are both null |
|
579 | * @see java.lang.Object#equals |
|
580 | */ |
|
581 | private boolean equals (Object a, Object b) |
|
582 | { |
|
583 | 0 | return ((a == null && b == null) || |
584 | (a != null && a.equals(b))); |
|
585 | } |
|
586 | ||
587 | ||
588 | //////////////////////////////////////////////////////////////////// |
|
589 | // Internal state. |
|
590 | //////////////////////////////////////////////////////////////////// |
|
591 | ||
592 | private Node parent; |
|
593 | private String name; |
|
594 | private String value; |
|
595 | ||
596 | ||
597 | ||
598 | //////////////////////////////////////////////////////////////////// |
|
599 | // Inner class: empty node list. |
|
600 | //////////////////////////////////////////////////////////////////// |
|
601 | ||
602 | ||
603 | /** |
|
604 | * A node list with no members. |
|
605 | * |
|
606 | * <p>This class is necessary for the {@link Node#getChildNodes} |
|
607 | * method, which must return an empty node list rather than |
|
608 | * null when there are no children.</p> |
|
609 | */ |
|
610 | 0 | private static class EmptyNodeList implements NodeList |
611 | { |
|
612 | ||
613 | /** |
|
614 | * @see NodeList#getLength |
|
615 | */ |
|
616 | public int getLength () |
|
617 | { |
|
618 | 0 | return 0; |
619 | } |
|
620 | ||
621 | ||
622 | /** |
|
623 | * @see NodeList#item |
|
624 | */ |
|
625 | public Node item(int index) |
|
626 | { |
|
627 | 0 | return null; |
628 | } |
|
629 | ||
630 | } |
|
631 | ||
632 | //////////////////////////////////////////////////////////////////// |
|
633 | // DOM Level 3 methods |
|
634 | //////////////////////////////////////////////////////////////////// |
|
635 | ||
636 | /** |
|
637 | * Return the base URI of the document containing this node (always fails). |
|
638 | * |
|
639 | * @return null |
|
640 | */ |
|
641 | public String getBaseURI() { |
|
642 | // XXX we could use reflection in DOM Level 3 to get this value |
|
643 | 0 | return null; |
644 | } |
|
645 | ||
646 | ||
647 | /** |
|
648 | * Compare relative position of this node to another nbode. (Always fails). |
|
649 | * |
|
650 | * @return never |
|
651 | * @throws DOMException NOT_SUPPORTED_ERR |
|
652 | */ |
|
653 | public short compareDocumentPosition(Node other) throws DOMException { |
|
654 | 0 | DOMException ex = new DOMException( |
655 | DOMException.NOT_SUPPORTED_ERR, |
|
656 | "DOM level 3 interfaces are not fully implemented in Jaxen's NamespaceNode class" |
|
657 | ); |
|
658 | 0 | throw ex; |
659 | } |
|
660 | ||
661 | ||
662 | /** |
|
663 | * Return the namespace URI. |
|
664 | * |
|
665 | * @return the namespace URI |
|
666 | * @see #getNodeValue |
|
667 | */ |
|
668 | public String getTextContent() { |
|
669 | 6 | return value; |
670 | } |
|
671 | ||
672 | ||
673 | /** |
|
674 | * Change the value of this node (always fails). |
|
675 | * |
|
676 | * @param textContent the new content |
|
677 | * @throws DOMException always |
|
678 | */ |
|
679 | public void setTextContent(String textContent) throws DOMException { |
|
680 | 6 | disallowModification(); |
681 | 0 | } |
682 | ||
683 | ||
684 | /** |
|
685 | * Returns true if and only if this object represents the same XPath namespace node |
|
686 | * as the argument; that is, they have the same parent, the same prefix, and the |
|
687 | * same URI. |
|
688 | * |
|
689 | * @param other the node to compare to |
|
690 | * @return true if this object represents the same XPath namespace node |
|
691 | * as other; false otherwise |
|
692 | */ |
|
693 | public boolean isSameNode(Node other) { |
|
694 | 12 | return this.isEqualNode(other) |
695 | // a bit flaky (should really be this.getParentNode().isEqual(other.getParentNode()) |
|
696 | // but we want this to compile in Java 1.4 without problems |
|
697 | && this.getParentNode() == other.getParentNode(); |
|
698 | } |
|
699 | ||
700 | ||
701 | /** |
|
702 | * Return the prefix bound to this namespace URI within the scope |
|
703 | * of this node (always fails). |
|
704 | * |
|
705 | * @return never |
|
706 | * @throws UnsupportedOperationException always |
|
707 | */ |
|
708 | public String lookupPrefix(String namespaceURI) { |
|
709 | // XXX This could be implemented. See |
|
710 | // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#lookupNamespaceURIAlgo |
|
711 | // It hardly seems worth the effort though. |
|
712 | 0 | throw new UnsupportedOperationException("Changing interfaces in a JDK blows chunks!"); |
713 | } |
|
714 | ||
715 | ||
716 | /** |
|
717 | * Return true if the specified URI is the default namespace in |
|
718 | * scope (always fails). |
|
719 | * |
|
720 | * @return never |
|
721 | * @throws UnsupportedOperationException always |
|
722 | */ |
|
723 | public boolean isDefaultNamespace(String namespaceURI) { |
|
724 | 0 | return namespaceURI.equals(this.lookupNamespaceURI(null)); |
725 | } |
|
726 | ||
727 | ||
728 | /** |
|
729 | * Return the namespace URI mapped to the specified |
|
730 | * prefix within the scope of this namespace node (always fails). |
|
731 | * |
|
732 | * @return never |
|
733 | * @throws UnsupportedOperationException always |
|
734 | */ |
|
735 | public String lookupNamespaceURI(String prefix) { |
|
736 | // XXX This could be implemented. See |
|
737 | // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#lookupNamespaceURIAlgo |
|
738 | // It hardly seems worth the effort though. |
|
739 | 0 | throw new UnsupportedOperationException("Changing interfaces in a JDK blows chunks!"); |
740 | } |
|
741 | ||
742 | ||
743 | /** |
|
744 | * Returns true if this object binds the same prefix to the same URI. |
|
745 | * That is, this object has the same prefix and URI as the argument. |
|
746 | * |
|
747 | * @param arg the node to compare to |
|
748 | * @return true if this object has the same prefix and URI as the argument; false otherwise |
|
749 | */ |
|
750 | public boolean isEqualNode(Node arg) { |
|
751 | 24 | if (arg.getNodeType() == this.getNodeType()) { |
752 | 24 | NamespaceNode other = (NamespaceNode) arg; |
753 | 24 | if (other.name == null && this.name != null) return false; |
754 | 24 | else if (other.name != null && this.name == null) return false; |
755 | 12 | else if (other.value == null && this.value != null) return false; |
756 | 12 | else if (other.value != null && this.value == null) return false; |
757 | 12 | else if (other.name == null && this.name == null) { |
758 | 12 | return other.value.equals(this.value); |
759 | } |
|
760 | ||
761 | 0 | return other.name.equals(this.name) && other.value.equals(this.value); |
762 | } |
|
763 | 0 | return false; |
764 | } |
|
765 | ||
766 | ||
767 | /** |
|
768 | * Returns the value of the requested feature. Always returns null. |
|
769 | * |
|
770 | * @return null |
|
771 | */ |
|
772 | public Object getFeature(String feature, String version) { |
|
773 | 6 | return null; |
774 | } |
|
775 | ||
776 | ||
777 | // XXX userdata needs testing |
|
778 | 1350 | private HashMap userData = new HashMap(); |
779 | ||
780 | /** |
|
781 | * Associates an object with a key. |
|
782 | * |
|
783 | * @param key the key by which the data will be retrieved |
|
784 | * @param data the object to store with the key |
|
785 | * @param handler ignored since nnamespace ndoes cannot be imported, cloned, or renamed |
|
786 | * |
|
787 | * @return the value previously associated with this key; or null |
|
788 | * if there isn't any such previous value |
|
789 | */ |
|
790 | public Object setUserData(String key, Object data, UserDataHandler handler) { |
|
791 | 0 | Object oldValue = getUserData(key); |
792 | 0 | userData.put(key, data); |
793 | 0 | return oldValue; |
794 | } |
|
795 | ||
796 | ||
797 | /** |
|
798 | * Returns the user data associated with the given key. |
|
799 | * |
|
800 | * @return the object associated with the key; or null if no such object is available |
|
801 | */ |
|
802 | public Object getUserData(String key) { |
|
803 | 0 | return userData.get(key); |
804 | } |
|
805 | ||
806 | } |
|
807 | ||
808 | // end of Namespace.java |