1 /*
   2  * reserved comment block
   3  * DO NOT REMOVE OR ALTER!
   4  */
   5 /*
   6  * Copyright 1999-2004 The Apache Software Foundation.
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *     http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20 /*
  21  * $Id: DTMNodeProxy.java,v
  22  */
  23 package com.sun.org.apache.xml.internal.dtm.ref;
  24 
  25 import java.util.Vector;
  26 
  27 import com.sun.org.apache.xml.internal.dtm.DTM;
  28 import com.sun.org.apache.xml.internal.dtm.DTMDOMException;
  29 import com.sun.org.apache.xpath.internal.NodeSet;

  30 
  31 import org.w3c.dom.Attr;
  32 import org.w3c.dom.CDATASection;
  33 import org.w3c.dom.Comment;
  34 import org.w3c.dom.DOMException;
  35 import org.w3c.dom.DOMImplementation;
  36 import org.w3c.dom.Document;
  37 import org.w3c.dom.DocumentFragment;
  38 import org.w3c.dom.DocumentType;
  39 import org.w3c.dom.Element;
  40 import org.w3c.dom.EntityReference;
  41 import org.w3c.dom.NamedNodeMap;
  42 import org.w3c.dom.Node;
  43 import org.w3c.dom.NodeList;
  44 import org.w3c.dom.ProcessingInstruction;
  45 import org.w3c.dom.Text;
  46 
  47 import org.w3c.dom.UserDataHandler;
  48 import org.w3c.dom.DOMConfiguration;
  49 import org.w3c.dom.TypeInfo;
  50 
  51 /**
  52  * <code>DTMNodeProxy</code> presents a DOM Node API front-end to the DTM model.
  53  * <p>
  54  * It does _not_ attempt to address the "node identity" question; no effort
  55  * is made to prevent the creation of multiple proxies referring to a single
  56  * DTM node. Users can create a mechanism for managing this, or relinquish the
  57  * use of "==" and use the .sameNodeAs() mechanism, which is under
  58  * consideration for future versions of the DOM.
  59  * <p>
  60  * DTMNodeProxy may be subclassed further to present specific DOM node types.
  61  *
  62  * @see org.w3c.dom
  63  */
  64 public class DTMNodeProxy
  65   implements Node, Document, Text, Element, Attr,
  66                    ProcessingInstruction, Comment, DocumentFragment
  67 {
  68 
  69   /** The DTM for this node. */
  70   public DTM dtm;
  71 
  72   /** The DTM node handle. */
  73   int node;
  74 
  75   /** The return value as Empty String. */
  76   private static final String EMPTYSTRING = "";
  77 
  78   /** The DOMImplementation object */
  79   static final DOMImplementation implementation=new DTMNodeProxyImplementation();
  80 
  81   /**
  82    * Create a DTMNodeProxy Node representing a specific Node in a DTM
  83    *
  84    * @param dtm The DTM Reference, must be non-null.
  85    * @param node The DTM node handle.
  86    */
  87   public DTMNodeProxy(DTM dtm, int node)
  88   {
  89     this.dtm = dtm;
  90     this.node = node;
  91   }
  92 
  93   /**
  94    * NON-DOM: Return the DTM model
  95    *
  96    * @return The DTM that this proxy is a representative for.
  97    */
  98   public final DTM getDTM()
  99   {
 100     return dtm;
 101   }
 102 
 103   /**
 104    * NON-DOM: Return the DTM node number
 105    *
 106    * @return The DTM node handle.
 107    */
 108   public final int getDTMNodeNumber()
 109   {
 110     return node;
 111   }
 112 
 113   /**
 114    * Test for equality based on node number.
 115    *
 116    * @param node A DTM node proxy reference.
 117    *
 118    * @return true if the given node has the same handle as this node.
 119    */
 120   public final boolean equals(Node node)
 121   {
 122 
 123     try
 124     {
 125       DTMNodeProxy dtmp = (DTMNodeProxy) node;
 126 
 127       // return (dtmp.node == this.node);
 128       // Patch attributed to Gary L Peskin <garyp@firstech.com>
 129       return (dtmp.node == this.node) && (dtmp.dtm == this.dtm);
 130     }
 131     catch (ClassCastException cce)
 132     {
 133       return false;
 134     }
 135   }
 136 
 137   /**
 138    * Test for equality based on node number.
 139    *
 140    * @param node A DTM node proxy reference.
 141    *
 142    * @return true if the given node has the same handle as this node.
 143    */

 144   public final boolean equals(Object node)
 145   {
 146 
 147     try
 148     {
 149 
 150       // DTMNodeProxy dtmp = (DTMNodeProxy)node;
 151       // return (dtmp.node == this.node);
 152       // Patch attributed to Gary L Peskin <garyp@firstech.com>
 153       return equals((Node) node);
 154     }
 155     catch (ClassCastException cce)
 156     {
 157       return false;
 158     }







 159   }
 160 
 161   /**
 162    * FUTURE DOM: Test node identity, in lieu of Node==Node
 163    *
 164    * @param other
 165    *
 166    * @return true if the given node has the same handle as this node.
 167    */
 168   public final boolean sameNodeAs(Node other)
 169   {
 170 
 171     if (!(other instanceof DTMNodeProxy))
 172       return false;
 173 
 174     DTMNodeProxy that = (DTMNodeProxy) other;
 175 
 176     return this.dtm == that.dtm && this.node == that.node;
 177   }
 178 
 179   /**
 180    *
 181    *
 182    * @see org.w3c.dom.Node
 183    */

 184   public final String getNodeName()
 185   {
 186     return dtm.getNodeName(node);
 187   }
 188 
 189   /**
 190    * A PI's "target" states what processor channel the PI's data
 191    * should be directed to. It is defined differently in HTML and XML.
 192    * <p>
 193    * In XML, a PI's "target" is the first (whitespace-delimited) token
 194    * following the "<?" token that begins the PI.
 195    * <p>
 196    * In HTML, target is always null.
 197    * <p>
 198    * Note that getNodeName is aliased to getTarget.
 199    *
 200    *
 201    */

 202   public final String getTarget()
 203   {
 204     return dtm.getNodeName(node);
 205   }  // getTarget():String
 206 
 207   /**
 208    *
 209    *
 210    * @see org.w3c.dom.Node as of DOM Level 2
 211    */

 212   public final String getLocalName()
 213   {
 214     return dtm.getLocalName(node);
 215   }
 216 
 217   /**
 218    * @return The prefix for this node.
 219    * @see org.w3c.dom.Node as of DOM Level 2
 220    */

 221   public final String getPrefix()
 222   {
 223     return dtm.getPrefix(node);
 224   }
 225 
 226   /**
 227    *
 228    * @param prefix
 229    *
 230    * @throws DOMException
 231    * @see org.w3c.dom.Node as of DOM Level 2 -- DTMNodeProxy is read-only
 232    */

 233   public final void setPrefix(String prefix) throws DOMException
 234   {
 235     throw new DTMDOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR);
 236   }
 237 
 238   /**
 239    *
 240    *
 241    * @see org.w3c.dom.Node as of DOM Level 2
 242    */

 243   public final String getNamespaceURI()
 244   {
 245     return dtm.getNamespaceURI(node);
 246   }
 247 
 248   /** Ask whether we support a given DOM feature.
 249    * In fact, we do not _fully_ support any DOM feature -- we're a
 250    * read-only subset -- so arguably we should always return false.
 251    * Or we could say that we support DOM Core Level 2 but all nodes
 252    * are read-only. Unclear which answer is least misleading.
 253    *
 254    * NON-DOM method. This was present in early drafts of DOM Level 2,
 255    * but was renamed isSupported. It's present here only because it's
 256    * cheap, harmless, and might help some poor fool who is still trying
 257    * to use an early Working Draft of the DOM.
 258    *
 259    * @param feature
 260    * @param version
 261    *
 262    * @return false
 263    */
 264   public final boolean supports(String feature, String version)
 265   {
 266     return implementation.hasFeature(feature,version);
 267     //throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
 268   }
 269 
 270   /** Ask whether we support a given DOM feature.
 271    * In fact, we do not _fully_ support any DOM feature -- we're a
 272    * read-only subset -- so arguably we should always return false.
 273    *
 274    * @param feature
 275    * @param version
 276    *
 277    * @return false
 278    * @see org.w3c.dom.Node as of DOM Level 2
 279    */

 280   public final boolean isSupported(String feature, String version)
 281   {
 282     return implementation.hasFeature(feature,version);
 283     // throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
 284   }
 285 
 286   /**
 287    *
 288    *
 289    *
 290    * @throws DOMException
 291    * @see org.w3c.dom.Node
 292    */

 293   public final String getNodeValue() throws DOMException
 294   {
 295     return dtm.getNodeValue(node);
 296   }
 297 
 298   /**
 299    * @return The string value of the node
 300    *
 301    * @throws DOMException
 302    */
 303   public final String getStringValue() throws DOMException
 304   {
 305         return dtm.getStringValue(node).toString();
 306   }
 307 
 308   /**
 309    *
 310    * @param nodeValue
 311    *
 312    * @throws DOMException
 313    * @see org.w3c.dom.Node -- DTMNodeProxy is read-only
 314    */

 315   public final void setNodeValue(String nodeValue) throws DOMException
 316   {
 317     throw new DTMDOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR);
 318   }
 319 
 320   /**
 321    *
 322    *
 323    * @see org.w3c.dom.Node
 324    */

 325   public final short getNodeType()
 326   {
 327     return (short) dtm.getNodeType(node);
 328   }
 329 
 330   /**
 331    *
 332    *
 333    * @see org.w3c.dom.Node
 334    */

 335   public final Node getParentNode()
 336   {
 337 
 338     if (getNodeType() == Node.ATTRIBUTE_NODE)
 339       return null;
 340 
 341     int newnode = dtm.getParent(node);
 342 
 343     return (newnode == DTM.NULL) ? null : dtm.getNode(newnode);
 344   }
 345 
 346   /**
 347    *
 348    *
 349    * @see org.w3c.dom.Node
 350    */
 351   public final Node getOwnerNode()
 352   {
 353 
 354     int newnode = dtm.getParent(node);
 355 
 356     return (newnode == DTM.NULL) ? null : dtm.getNode(newnode);
 357   }
 358 
 359   /**
 360    *
 361    *
 362    * @see org.w3c.dom.Node
 363    */

 364   public final NodeList getChildNodes()
 365   {
 366 
 367     // Annoyingly, AxisIterators do not currently implement DTMIterator, so
 368     // we can't just wap DTMNodeList around an Axis.CHILD iterator.
 369     // Instead, we've created a special-case operating mode for that object.
 370     return new DTMChildIterNodeList(dtm,node);
 371 
 372     // throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
 373   }
 374 
 375   /**
 376    *
 377    *
 378    * @see org.w3c.dom.Node
 379    */

 380   public final Node getFirstChild()
 381   {
 382 
 383     int newnode = dtm.getFirstChild(node);
 384 
 385     return (newnode == DTM.NULL) ? null : dtm.getNode(newnode);
 386   }
 387 
 388   /**
 389    *
 390    *
 391    * @see org.w3c.dom.Node
 392    */

 393   public final Node getLastChild()
 394   {
 395 
 396     int newnode = dtm.getLastChild(node);
 397 
 398     return (newnode == DTM.NULL) ? null : dtm.getNode(newnode);
 399   }
 400 
 401   /**
 402    *
 403    *
 404    * @see org.w3c.dom.Node
 405    */

 406   public final Node getPreviousSibling()
 407   {
 408 
 409     int newnode = dtm.getPreviousSibling(node);
 410 
 411     return (newnode == DTM.NULL) ? null : dtm.getNode(newnode);
 412   }
 413 
 414   /**
 415    *
 416    *
 417    * @see org.w3c.dom.Node
 418    */

 419   public final Node getNextSibling()
 420   {
 421 
 422     // Attr's Next is defined at DTM level, but not at DOM level.
 423     if (dtm.getNodeType(node) == Node.ATTRIBUTE_NODE)
 424       return null;
 425 
 426     int newnode = dtm.getNextSibling(node);
 427 
 428     return (newnode == DTM.NULL) ? null : dtm.getNode(newnode);
 429   }
 430 
 431   // DTMNamedNodeMap m_attrs;
 432 
 433   /**
 434    *
 435    *
 436    * @see org.w3c.dom.Node
 437    */

 438   public final NamedNodeMap getAttributes()
 439   {
 440 
 441     return new DTMNamedNodeMap(dtm, node);
 442   }
 443 
 444   /**
 445    * Method hasAttribute
 446    *
 447    *
 448    * @param name
 449    *
 450    */

 451   public boolean hasAttribute(String name)
 452   {
 453     return DTM.NULL != dtm.getAttributeNode(node,null,name);
 454   }
 455 
 456   /**
 457    * Method hasAttributeNS
 458    *
 459    *
 460    * @param namespaceURI
 461    * @param localName
 462    *
 463    *
 464    */

 465   public boolean hasAttributeNS(String namespaceURI, String localName)
 466   {
 467     return DTM.NULL != dtm.getAttributeNode(node,namespaceURI,localName);
 468   }
 469 
 470   /**
 471    *
 472    *
 473    * @see org.w3c.dom.Node
 474    */

 475   public final Document getOwnerDocument()
 476   {
 477         // Note that this uses the DOM-compatable version of the call
 478         return (Document)(dtm.getNode(dtm.getOwnerDocument(node)));
 479   }
 480 
 481   /**
 482    *
 483    * @param newChild
 484    * @param refChild
 485    *
 486    *
 487    *
 488    * @throws DOMException
 489    * @see org.w3c.dom.Node -- DTMNodeProxy is read-only
 490    */

 491   public final Node insertBefore(Node newChild, Node refChild)
 492     throws DOMException
 493   {
 494     throw new DTMDOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR);
 495   }
 496 
 497   /**
 498    *
 499    * @param newChild
 500    * @param oldChild
 501    *
 502    *
 503    *
 504    * @throws DOMException
 505    * @see org.w3c.dom.Node -- DTMNodeProxy is read-only
 506    */

 507   public final Node replaceChild(Node newChild, Node oldChild)
 508     throws DOMException
 509   {
 510     throw new DTMDOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR);
 511   }
 512 
 513   /**
 514    *
 515    * @param oldChild
 516    *
 517    *
 518    *
 519    * @throws DOMException
 520    * @see org.w3c.dom.Node -- DTMNodeProxy is read-only
 521    */

 522   public final Node removeChild(Node oldChild) throws DOMException
 523   {
 524     throw new DTMDOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR);
 525   }
 526 
 527   /**
 528    *
 529    * @param newChild
 530    *
 531    *
 532    *
 533    * @throws DOMException
 534    * @see org.w3c.dom.Node -- DTMNodeProxy is read-only
 535    */

 536   public final Node appendChild(Node newChild) throws DOMException
 537   {
 538     throw new DTMDOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR);
 539   }
 540 
 541   /**
 542    *
 543    *
 544    * @see org.w3c.dom.Node
 545    */

 546   public final boolean hasChildNodes()
 547   {
 548     return (DTM.NULL != dtm.getFirstChild(node));
 549   }
 550 
 551   /**
 552    *
 553    * @param deep
 554    *
 555    *
 556    * @see org.w3c.dom.Node -- DTMNodeProxy is read-only
 557    */

 558   public final Node cloneNode(boolean deep)
 559   {
 560     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
 561   }
 562 
 563   /**
 564    *
 565    *
 566    * @see org.w3c.dom.Document
 567    */

 568   public final DocumentType getDoctype()
 569   {
 570     return null;
 571   }
 572 
 573   /**
 574    *
 575    *
 576    * @see org.w3c.dom.Document
 577    */

 578   public final DOMImplementation getImplementation()
 579   {
 580     return implementation;
 581   }
 582 
 583   /** This is a bit of a problem in DTM, since a DTM may be a Document
 584    * Fragment and hence not have a clear-cut Document Element. We can
 585    * make it work in the well-formed cases but would that be confusing for others?
 586    *
 587    *
 588    * @see org.w3c.dom.Document
 589    */

 590   public final Element getDocumentElement()
 591   {
 592                 int dochandle=dtm.getDocument();
 593                 int elementhandle=DTM.NULL;
 594                 for(int kidhandle=dtm.getFirstChild(dochandle);
 595                                 kidhandle!=DTM.NULL;
 596                                 kidhandle=dtm.getNextSibling(kidhandle))
 597                 {
 598                         switch(dtm.getNodeType(kidhandle))
 599                         {
 600                         case Node.ELEMENT_NODE:
 601                                 if(elementhandle!=DTM.NULL)
 602                                 {
 603                                         elementhandle=DTM.NULL; // More than one; ill-formed.
 604                                         kidhandle=dtm.getLastChild(dochandle); // End loop
 605                                 }
 606                                 else
 607                                         elementhandle=kidhandle;
 608                                 break;
 609 
 610                         // These are harmless; document is still wellformed
 611                         case Node.COMMENT_NODE:
 612                         case Node.PROCESSING_INSTRUCTION_NODE:
 613                         case Node.DOCUMENT_TYPE_NODE:
 614                                 break;
 615 
 616                         default:
 617                                 elementhandle=DTM.NULL; // ill-formed
 618                                 kidhandle=dtm.getLastChild(dochandle); // End loop
 619                                 break;
 620                         }
 621                 }
 622                 if(elementhandle==DTM.NULL)
 623                         throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
 624                 else
 625                         return (Element)(dtm.getNode(elementhandle));
 626   }
 627 
 628   /**
 629    *
 630    * @param tagName
 631    *
 632    *
 633    *
 634    * @throws DOMException
 635    * @see org.w3c.dom.Document
 636    */

 637   public final Element createElement(String tagName) throws DOMException
 638   {
 639     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
 640   }
 641 
 642   /**
 643    *
 644    *
 645    * @see org.w3c.dom.Document
 646    */

 647   public final DocumentFragment createDocumentFragment()
 648   {
 649     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
 650   }
 651 
 652   /**
 653    *
 654    * @param data
 655    *
 656    *
 657    * @see org.w3c.dom.Document
 658    */

 659   public final Text createTextNode(String data)
 660   {
 661     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
 662   }
 663 
 664   /**
 665    *
 666    * @param data
 667    *
 668    *
 669    * @see org.w3c.dom.Document
 670    */

 671   public final Comment createComment(String data)
 672   {
 673     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
 674   }
 675 
 676   /**
 677    *
 678    * @param data
 679    *
 680    *
 681    *
 682    * @throws DOMException
 683    * @see org.w3c.dom.Document
 684    */

 685   public final CDATASection createCDATASection(String data)
 686     throws DOMException
 687   {
 688     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
 689   }
 690 
 691   /**
 692    *
 693    * @param target
 694    * @param data
 695    *
 696    *
 697    *
 698    * @throws DOMException
 699    * @see org.w3c.dom.Document
 700    */

 701   public final ProcessingInstruction createProcessingInstruction(
 702                                                                  String target, String data) throws DOMException
 703   {
 704     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
 705   }
 706 
 707   /**
 708    *
 709    * @param name
 710    *
 711    *
 712    *
 713    * @throws DOMException
 714    * @see org.w3c.dom.Document
 715    */

 716   public final Attr createAttribute(String name) throws DOMException
 717   {
 718     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
 719   }
 720 
 721   /**
 722    *
 723    * @param name
 724    *
 725    *
 726    *
 727    * @throws DOMException
 728    * @see org.w3c.dom.Document
 729    */

 730   public final EntityReference createEntityReference(String name)
 731     throws DOMException
 732   {
 733     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
 734   }
 735  /**
 736    *
 737    * @param tagname
 738    *
 739    *
 740    * @see org.w3c.dom.Document
 741    */

 742   public final NodeList getElementsByTagName(String tagname)
 743   {
 744        Vector listVector = new Vector();
 745        Node retNode = dtm.getNode(node);
 746        if (retNode != null)
 747        {
 748          boolean isTagNameWildCard = "*".equals(tagname);
 749          if (DTM.ELEMENT_NODE == retNode.getNodeType())
 750          {
 751            NodeList nodeList = retNode.getChildNodes();
 752            for (int i = 0; i < nodeList.getLength(); i++)
 753            {
 754              traverseChildren(listVector, nodeList.item(i), tagname,
 755                               isTagNameWildCard);
 756            }
 757          } else if (DTM.DOCUMENT_NODE == retNode.getNodeType()) {
 758            traverseChildren(listVector, dtm.getNode(node), tagname,
 759                             isTagNameWildCard);
 760          }
 761        }
 762        int size = listVector.size();
 763        NodeSet nodeSet = new NodeSet(size);
 764        for (int i = 0; i < size; i++)
 765        {
 766          nodeSet.addNode((Node) listVector.elementAt(i));
 767        }
 768        return (NodeList) nodeSet;
 769   }
 770 
 771   /**
 772    *
 773    * @param listVector
 774    * @param tempNode
 775    * @param tagname
 776    * @param isTagNameWildCard
 777    *
 778    *
 779    * Private method to be used for recursive iterations to obtain elements by tag name.
 780    */
 781   private final void traverseChildren
 782   (
 783     Vector listVector,
 784     Node tempNode,
 785     String tagname,
 786     boolean isTagNameWildCard) {
 787     if (tempNode == null)
 788     {
 789       return;
 790     }
 791     else
 792     {
 793       if (tempNode.getNodeType() == DTM.ELEMENT_NODE
 794             && (isTagNameWildCard || tempNode.getNodeName().equals(tagname)))
 795       {
 796         listVector.add(tempNode);
 797       }
 798       if(tempNode.hasChildNodes())
 799       {
 800         NodeList nodeList = tempNode.getChildNodes();
 801         for (int i = 0; i < nodeList.getLength(); i++)
 802         {
 803           traverseChildren(listVector, nodeList.item(i), tagname,
 804                            isTagNameWildCard);
 805         }
 806       }
 807     }
 808   }
 809 
 810 
 811 
 812   /**
 813    *
 814    * @param importedNode
 815    * @param deep
 816    *
 817    *
 818    *
 819    * @throws DOMException
 820    * @see org.w3c.dom.Document as of DOM Level 2 -- DTMNodeProxy is read-only
 821    */

 822   public final Node importNode(Node importedNode, boolean deep)
 823     throws DOMException
 824   {
 825     throw new DTMDOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR);
 826   }
 827 
 828   /**
 829    *
 830    * @param namespaceURI
 831    * @param qualifiedName
 832    *
 833    *
 834    *
 835    * @throws DOMException
 836    * @see org.w3c.dom.Document as of DOM Level 2
 837    */

 838   public final Element createElementNS(
 839                                        String namespaceURI, String qualifiedName) throws DOMException
 840   {
 841     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
 842   }
 843 
 844   /**
 845    *
 846    * @param namespaceURI
 847    * @param qualifiedName
 848    *
 849    *
 850    *
 851    * @throws DOMException
 852    * @see org.w3c.dom.Document as of DOM Level 2
 853    */

 854   public final Attr createAttributeNS(
 855                                       String namespaceURI, String qualifiedName) throws DOMException
 856   {
 857     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
 858   }
 859 
 860    /**
 861    *
 862    * @param namespaceURI
 863    * @param localName
 864    *
 865    *
 866    * @see org.w3c.dom.Document as of DOM Level 2
 867    */

 868   public final NodeList getElementsByTagNameNS(String namespaceURI,
 869                                                String localName)
 870   {
 871     Vector listVector = new Vector();
 872     Node retNode = dtm.getNode(node);
 873     if (retNode != null)
 874     {
 875       boolean isNamespaceURIWildCard = "*".equals(namespaceURI);
 876       boolean isLocalNameWildCard    = "*".equals(localName);
 877       if (DTM.ELEMENT_NODE == retNode.getNodeType())
 878       {
 879         NodeList nodeList = retNode.getChildNodes();
 880         for(int i = 0; i < nodeList.getLength(); i++)
 881         {
 882           traverseChildren(listVector, nodeList.item(i), namespaceURI, localName, isNamespaceURIWildCard, isLocalNameWildCard);
 883         }
 884       }
 885       else if(DTM.DOCUMENT_NODE == retNode.getNodeType())
 886       {
 887         traverseChildren(listVector, dtm.getNode(node), namespaceURI, localName, isNamespaceURIWildCard, isLocalNameWildCard);
 888       }
 889     }
 890     int size = listVector.size();
 891     NodeSet nodeSet = new NodeSet(size);
 892     for (int i = 0; i < size; i++)
 893     {
 894       nodeSet.addNode((Node)listVector.elementAt(i));
 895     }
 896     return (NodeList) nodeSet;
 897   }
 898   /**
 899    *
 900    * @param listVector
 901    * @param tempNode
 902    * @param namespaceURI
 903    * @param localname
 904    * @param isNamespaceURIWildCard
 905    * @param isLocalNameWildCard
 906    *
 907    * Private method to be used for recursive iterations to obtain elements by tag name
 908    * and namespaceURI.
 909    */
 910   private final void traverseChildren
 911   (
 912    Vector listVector,
 913    Node tempNode,
 914    String namespaceURI,
 915    String localname,
 916    boolean isNamespaceURIWildCard,
 917    boolean isLocalNameWildCard)
 918    {
 919     if (tempNode == null)
 920     {
 921       return;
 922     }
 923     else
 924     {
 925       if (tempNode.getNodeType() == DTM.ELEMENT_NODE
 926               && (isLocalNameWildCard
 927                       || tempNode.getLocalName().equals(localname)))
 928       {
 929         String nsURI = tempNode.getNamespaceURI();
 930         if ((namespaceURI == null && nsURI == null)
 931                || isNamespaceURIWildCard
 932                || (namespaceURI != null && namespaceURI.equals(nsURI)))
 933         {
 934           listVector.add(tempNode);
 935         }
 936       }
 937       if(tempNode.hasChildNodes())
 938       {
 939         NodeList nl = tempNode.getChildNodes();
 940         for(int i = 0; i < nl.getLength(); i++)
 941         {
 942           traverseChildren(listVector, nl.item(i), namespaceURI, localname,
 943                            isNamespaceURIWildCard, isLocalNameWildCard);
 944         }
 945       }
 946     }
 947   }
 948   /**
 949    *
 950    * @param elementId
 951    *
 952    *
 953    * @see org.w3c.dom.Document as of DOM Level 2
 954    */

 955   public final Element getElementById(String elementId)
 956   {
 957        return (Element) dtm.getNode(dtm.getElementById(elementId));
 958   }
 959 
 960   /**
 961    *
 962    * @param offset
 963    *
 964    *
 965    *
 966    * @throws DOMException
 967    * @see org.w3c.dom.Text
 968    */

 969   public final Text splitText(int offset) throws DOMException
 970   {
 971     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
 972   }
 973 
 974   /**
 975    *
 976    *
 977    *
 978    * @throws DOMException
 979    * @see org.w3c.dom.CharacterData
 980    */

 981   public final String getData() throws DOMException
 982   {
 983     return dtm.getNodeValue(node);
 984   }
 985 
 986   /**
 987    *
 988    * @param data
 989    *
 990    * @throws DOMException
 991    * @see org.w3c.dom.CharacterData
 992    */

 993   public final void setData(String data) throws DOMException
 994   {
 995     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
 996   }
 997 
 998   /**
 999    *
1000    *
1001    * @see org.w3c.dom.CharacterData
1002    */

1003   public final int getLength()
1004   {
1005     // %OPT% This should do something smarter?
1006     return dtm.getNodeValue(node).length();
1007   }
1008 
1009   /**
1010    *
1011    * @param offset
1012    * @param count
1013    *
1014    *
1015    *
1016    * @throws DOMException
1017    * @see org.w3c.dom.CharacterData
1018    */

1019   public final String substringData(int offset, int count) throws DOMException
1020   {
1021     return getData().substring(offset,offset+count);
1022   }
1023 
1024   /**
1025    *
1026    * @param arg
1027    *
1028    * @throws DOMException
1029    * @see org.w3c.dom.CharacterData
1030    */

1031   public final void appendData(String arg) throws DOMException
1032   {
1033     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
1034   }
1035 
1036   /**
1037    *
1038    * @param offset
1039    * @param arg
1040    *
1041    * @throws DOMException
1042    * @see org.w3c.dom.CharacterData
1043    */

1044   public final void insertData(int offset, String arg) throws DOMException
1045   {
1046     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
1047   }
1048 
1049   /**
1050    *
1051    * @param offset
1052    * @param count
1053    *
1054    * @throws DOMException
1055    * @see org.w3c.dom.CharacterData
1056    */

1057   public final void deleteData(int offset, int count) throws DOMException
1058   {
1059     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
1060   }
1061 
1062   /**
1063    *
1064    * @param offset
1065    * @param count
1066    * @param arg
1067    *
1068    * @throws DOMException
1069    * @see org.w3c.dom.CharacterData
1070    */

1071   public final void replaceData(int offset, int count, String arg)
1072     throws DOMException
1073   {
1074     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
1075   }
1076 
1077   /**
1078    *
1079    *
1080    * @see org.w3c.dom.Element
1081    */

1082   public final String getTagName()
1083   {
1084     return dtm.getNodeName(node);
1085   }
1086 
1087   /**
1088    *
1089    * @param name
1090    *
1091    *
1092    * @see org.w3c.dom.Element
1093    */

1094   public final String getAttribute(String name)
1095   {
1096 
1097     DTMNamedNodeMap  map = new DTMNamedNodeMap(dtm, node);
1098     Node node = map.getNamedItem(name);
1099     return (null == node) ? EMPTYSTRING : node.getNodeValue();  }

1100 
1101   /**
1102    *
1103    * @param name
1104    * @param value
1105    *
1106    * @throws DOMException
1107    * @see org.w3c.dom.Element
1108    */

1109   public final void setAttribute(String name, String value)
1110     throws DOMException
1111   {
1112     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
1113   }
1114 
1115   /**
1116    *
1117    * @param name
1118    *
1119    * @throws DOMException
1120    * @see org.w3c.dom.Element
1121    */

1122   public final void removeAttribute(String name) throws DOMException
1123   {
1124     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
1125   }
1126 
1127   /**
1128    *
1129    * @param name
1130    *
1131    *
1132    * @see org.w3c.dom.Element
1133    */

1134   public final Attr getAttributeNode(String name)
1135   {
1136 
1137     DTMNamedNodeMap  map = new DTMNamedNodeMap(dtm, node);
1138     return (Attr)map.getNamedItem(name);
1139   }
1140 
1141   /**
1142    *
1143    * @param newAttr
1144    *
1145    *
1146    *
1147    * @throws DOMException
1148    * @see org.w3c.dom.Element
1149    */

1150   public final Attr setAttributeNode(Attr newAttr) throws DOMException
1151   {
1152     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
1153   }
1154 
1155   /**
1156    *
1157    * @param oldAttr
1158    *
1159    *
1160    *
1161    * @throws DOMException
1162    * @see org.w3c.dom.Element
1163    */

1164   public final Attr removeAttributeNode(Attr oldAttr) throws DOMException
1165   {
1166     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
1167   }
1168 
1169   /**
1170    * Introduced in DOM Level 2.
1171    *
1172    *
1173    */

1174   public boolean hasAttributes()
1175   {
1176     return DTM.NULL != dtm.getFirstAttribute(node);
1177   }
1178 
1179   /** @see org.w3c.dom.Element */

1180   public final void normalize()
1181   {
1182     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
1183   }
1184 
1185   /**
1186    *
1187    * @param namespaceURI
1188    * @param localName
1189    *
1190    *
1191    * @see org.w3c.dom.Element
1192    */

1193   public final String getAttributeNS(String namespaceURI, String localName)
1194   {
1195     Node retNode = null;
1196     int n = dtm.getAttributeNode(node,namespaceURI,localName);
1197     if(n != DTM.NULL)
1198             retNode = dtm.getNode(n);
1199     return (null == retNode) ? EMPTYSTRING : retNode.getNodeValue();
1200   }
1201 
1202   /**
1203    *
1204    * @param namespaceURI
1205    * @param qualifiedName
1206    * @param value
1207    *
1208    * @throws DOMException
1209    * @see org.w3c.dom.Element
1210    */

1211   public final void setAttributeNS(
1212                                    String namespaceURI, String qualifiedName, String value)
1213     throws DOMException
1214   {
1215     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
1216   }
1217 
1218   /**
1219    *
1220    * @param namespaceURI
1221    * @param localName
1222    *
1223    * @throws DOMException
1224    * @see org.w3c.dom.Element
1225    */

1226   public final void removeAttributeNS(String namespaceURI, String localName)
1227     throws DOMException
1228   {
1229     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
1230   }
1231 
1232   /**
1233    *
1234    * @param namespaceURI
1235    * @param localName
1236    *
1237    *
1238    * @see org.w3c.dom.Element
1239    */

1240   public final Attr getAttributeNodeNS(String namespaceURI, String localName)
1241   {
1242        Attr retAttr = null;
1243        int n = dtm.getAttributeNode(node,namespaceURI,localName);
1244        if(n != DTM.NULL)
1245                retAttr = (Attr) dtm.getNode(n);
1246        return retAttr;
1247 
1248   }
1249 
1250   /**
1251    *
1252    * @param newAttr
1253    *
1254    *
1255    *
1256    * @throws DOMException
1257    * @see org.w3c.dom.Element
1258    */

1259   public final Attr setAttributeNodeNS(Attr newAttr) throws DOMException
1260   {
1261     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
1262   }
1263 
1264   /**
1265    *
1266    *
1267    * @see org.w3c.dom.Attr
1268    */

1269   public final String getName()
1270   {
1271     return dtm.getNodeName(node);
1272   }
1273 
1274   /**
1275    *
1276    *
1277    * @see org.w3c.dom.Attr
1278    */

1279   public final boolean getSpecified()
1280   {
1281     // We really don't know which attributes might have come from the
1282     // source document versus from the DTD. Treat them all as having
1283     // been provided by the user.
1284     // %REVIEW% if/when we become aware of DTDs/schemae.
1285     return true;
1286   }
1287 
1288   /**
1289    *
1290    *
1291    * @see org.w3c.dom.Attr
1292    */

1293   public final String getValue()
1294   {
1295     return dtm.getNodeValue(node);
1296   }
1297 
1298   /**
1299    *
1300    * @param value
1301    * @see org.w3c.dom.Attr
1302    */

1303   public final void setValue(String value)
1304   {
1305     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
1306   }
1307 
1308   /**
1309    * Get the owner element of an attribute.
1310    *
1311    *
1312    * @see org.w3c.dom.Attr as of DOM Level 2
1313    */

1314   public final Element getOwnerElement()
1315   {
1316     if (getNodeType() != Node.ATTRIBUTE_NODE)
1317       return null;
1318     // In XPath and DTM data models, unlike DOM, an Attr's parent is its
1319     // owner element.
1320     int newnode = dtm.getParent(node);
1321     return (newnode == DTM.NULL) ? null : (Element)(dtm.getNode(newnode));
1322   }
1323 
1324   /**
1325    * NEEDSDOC Method adoptNode
1326    *
1327    *
1328    * NEEDSDOC @param source
1329    *
1330    * NEEDSDOC (adoptNode) @return
1331    *
1332    * @throws DOMException
1333    */

1334   public Node adoptNode(Node source) throws DOMException
1335   {
1336 
1337     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
1338   }
1339 
1340   /**
1341    * <p>EXPERIMENTAL! Based on the <a
1342    * href='http://www.w3.org/TR/2001/WD-DOM-Level-3-Core-20010605'>Document
1343    * Object Model (DOM) Level 3 Core Working Draft of 5 June 2001.</a>.
1344    * <p>
1345    * An attribute specifying, as part of the XML declaration, the encoding
1346    * of this document. This is <code>null</code> when unspecified.
1347    * @since DOM Level 3
1348    *
1349    * NEEDSDOC ($objectName$) @return
1350    */

1351   public String getInputEncoding()
1352   {
1353 
1354     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
1355   }
1356 
1357   /**
1358    * <p>EXPERIMENTAL! Based on the <a
1359    * href='http://www.w3.org/TR/2001/WD-DOM-Level-3-Core-20010605'>Document
1360    * Object Model (DOM) Level 3 Core Working Draft of 5 June 2001.</a>.
1361    * <p>
1362    * An attribute specifying, as part of the XML declaration, the encoding
1363    * of this document. This is <code>null</code> when unspecified.
1364    * @since DOM Level 3
1365    *
1366    * NEEDSDOC @param encoding
1367    */
1368   public void setEncoding(String encoding)
1369   {
1370     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
1371   }
1372 
1373   /**
1374    * <p>EXPERIMENTAL! Based on the <a
1375    * href='http://www.w3.org/TR/2001/WD-DOM-Level-3-Core-20010605'>Document
1376    * Object Model (DOM) Level 3 Core Working Draft of 5 June 2001.</a>.
1377    * <p>
1378    * An attribute specifying, as part of the XML declaration, whether this
1379    * document is standalone.
1380    * @since DOM Level 3
1381    *
1382    * NEEDSDOC ($objectName$) @return
1383    */
1384   public boolean getStandalone()
1385   {
1386 
1387     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
1388   }
1389 
1390   /**
1391    * <p>EXPERIMENTAL! Based on the <a
1392    * href='http://www.w3.org/TR/2001/WD-DOM-Level-3-Core-20010605'>Document
1393    * Object Model (DOM) Level 3 Core Working Draft of 5 June 2001.</a>.
1394    * <p>
1395    * An attribute specifying, as part of the XML declaration, whether this
1396    * document is standalone.
1397    * @since DOM Level 3
1398    *
1399    * NEEDSDOC @param standalone
1400    */
1401   public void setStandalone(boolean standalone)
1402   {
1403     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
1404   }
1405 
1406   /**
1407    * <p>EXPERIMENTAL! Based on the <a
1408    * href='http://www.w3.org/TR/2001/WD-DOM-Level-3-Core-20010605'>Document
1409    * Object Model (DOM) Level 3 Core Working Draft of 5 June 2001.</a>.
1410    * <p>
1411    * An attribute specifying whether errors checking is enforced or not.
1412    * When set to <code>false</code>, the implementation is free to not
1413    * test every possible error case normally defined on DOM operations,
1414    * and not raise any <code>DOMException</code>. In case of error, the
1415    * behavior is undefined. This attribute is <code>true</code> by
1416    * defaults.
1417    * @since DOM Level 3
1418    *
1419    * NEEDSDOC ($objectName$) @return
1420    */

1421   public boolean getStrictErrorChecking()
1422   {
1423 
1424     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
1425   }
1426 
1427   /**
1428    * <p>EXPERIMENTAL! Based on the <a
1429    * href='http://www.w3.org/TR/2001/WD-DOM-Level-3-Core-20010605'>Document
1430    * Object Model (DOM) Level 3 Core Working Draft of 5 June 2001.</a>.
1431    * <p>
1432    * An attribute specifying whether errors checking is enforced or not.
1433    * When set to <code>false</code>, the implementation is free to not
1434    * test every possible error case normally defined on DOM operations,
1435    * and not raise any <code>DOMException</code>. In case of error, the
1436    * behavior is undefined. This attribute is <code>true</code> by
1437    * defaults.
1438    * @since DOM Level 3
1439    *
1440    * NEEDSDOC @param strictErrorChecking
1441    */

1442   public void setStrictErrorChecking(boolean strictErrorChecking)
1443   {
1444     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
1445   }
1446 
1447   /**
1448    * <p>EXPERIMENTAL! Based on the <a
1449    * href='http://www.w3.org/TR/2001/WD-DOM-Level-3-Core-20010605'>Document
1450    * Object Model (DOM) Level 3 Core Working Draft of 5 June 2001.</a>.
1451    * <p>
1452    * An attribute specifying, as part of the XML declaration, the version
1453    * number of this document. This is <code>null</code> when unspecified.
1454    * @since DOM Level 3
1455    *
1456    * NEEDSDOC ($objectName$) @return
1457    */
1458   public String getVersion()
1459   {
1460 
1461     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
1462   }
1463 
1464   /**
1465    * <p>EXPERIMENTAL! Based on the <a
1466    * href='http://www.w3.org/TR/2001/WD-DOM-Level-3-Core-20010605'>Document
1467    * Object Model (DOM) Level 3 Core Working Draft of 5 June 2001.</a>.
1468    * <p>
1469    * An attribute specifying, as part of the XML declaration, the version
1470    * number of this document. This is <code>null</code> when unspecified.
1471    * @since DOM Level 3
1472    *
1473    * NEEDSDOC @param version
1474    */
1475   public void setVersion(String version)
1476   {
1477     throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
1478   }
1479 
1480 
1481   /** Inner class to support getDOMImplementation.
1482    */
1483   static class DTMNodeProxyImplementation implements DOMImplementation
1484   {

1485     public DocumentType createDocumentType(String qualifiedName,String publicId, String systemId)
1486     {
1487       throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
1488     }

1489     public Document createDocument(String namespaceURI,String qualfiedName,DocumentType doctype)
1490     {
1491       // Could create a DTM... but why, when it'd have to be permanantly empty?
1492       throw new DTMDOMException(DOMException.NOT_SUPPORTED_ERR);
1493     }
1494     /** Ask whether we support a given DOM feature.
1495      *
1496      * In fact, we do not _fully_ support any DOM feature -- we're a
1497      * read-only subset -- so arguably we should always return false.
1498      * On the other hand, it may be more practically useful to return
1499      * true and simply treat the whole DOM as read-only, failing on the
1500      * methods we can't support. I'm not sure which would be more useful
1501      * to the caller.
1502      */

1503     public boolean hasFeature(String feature,String version)
1504     {
1505       if( ("CORE".equals(feature.toUpperCase()) || "XML".equals(feature.toUpperCase()))
1506                                         &&
1507           ("1.0".equals(version) || "2.0".equals(version)))
1508         return true;
1509       return false;
1510     }
1511 
1512     /**
1513      *  This method returns a specialized object which implements the
1514      * specialized APIs of the specified feature and version. The
1515      * specialized object may also be obtained by using binding-specific
1516      * casting methods but is not necessarily expected to, as discussed in Mixed DOM implementations
1517 .
1518      * @param feature The name of the feature requested (case-insensitive).
1519      * @param version  This is the version number of the feature to test. If
1520      *   the version is <code>null</code> or the empty string, supporting
1521      *   any version of the feature will cause the method to return an
1522      *   object that supports at least one version of the feature.
1523      * @return  Returns an object which implements the specialized APIs of
1524      *   the specified feature and version, if any, or <code>null</code> if
1525      *   there is no object which implements interfaces associated with that
1526      *   feature. If the <code>DOMObject</code> returned by this method
1527      *   implements the <code>Node</code> interface, it must delegate to the
1528      *   primary core <code>Node</code> and not return results inconsistent
1529      *   with the primary core <code>Node</code> such as attributes,
1530      *   childNodes, etc.
1531      * @since DOM Level 3
1532      */

1533     public Object getFeature(String feature, String version) {
1534         // we don't have any alternate node, either this node does the job
1535         // or we don't have anything that does
1536         //return hasFeature(feature, version) ? this : null;
1537         return null; //PENDING
1538     }
1539 
1540   }
1541 
1542 
1543 //RAMESH : Pending proper implementation of DOM Level 3
1544 

1545     public Object setUserData(String key,
1546                               Object data,
1547                               UserDataHandler handler) {
1548         return getOwnerDocument().setUserData( key, data, handler);
1549     }
1550 
1551     /**
1552      * Retrieves the object associated to a key on a this node. The object
1553      * must first have been set to this node by calling
1554      * <code>setUserData</code> with the same key.
1555      * @param key The key the object is associated to.
1556      * @return Returns the <code>DOMObject</code> associated to the given key
1557      *   on this node, or <code>null</code> if there was none.
1558      * @since DOM Level 3
1559      */

1560     public Object getUserData(String key) {
1561         return getOwnerDocument().getUserData( key);
1562     }
1563 
1564       /**
1565      *  This method returns a specialized object which implements the
1566      * specialized APIs of the specified feature and version. The
1567      * specialized object may also be obtained by using binding-specific
1568      * casting methods but is not necessarily expected to, as discussed in Mixed DOM implementations.
1569      * @param feature The name of the feature requested (case-insensitive).
1570      * @param version  This is the version number of the feature to test. If
1571      *   the version is <code>null</code> or the empty string, supporting
1572      *   any version of the feature will cause the method to return an
1573      *   object that supports at least one version of the feature.
1574      * @return  Returns an object which implements the specialized APIs of
1575      *   the specified feature and version, if any, or <code>null</code> if
1576      *   there is no object which implements interfaces associated with that
1577      *   feature. If the <code>DOMObject</code> returned by this method
1578      *   implements the <code>Node</code> interface, it must delegate to the
1579      *   primary core <code>Node</code> and not return results inconsistent
1580      *   with the primary core <code>Node</code> such as attributes,
1581      *   childNodes, etc.
1582      * @since DOM Level 3
1583      */

1584     public Object getFeature(String feature, String version) {
1585         // we don't have any alternate node, either this node does the job
1586         // or we don't have anything that does
1587         return isSupported(feature, version) ? this : null;
1588     }
1589 
1590     /**
1591      * Tests whether two nodes are equal.
1592      * <br>This method tests for equality of nodes, not sameness (i.e.,
1593      * whether the two nodes are references to the same object) which can be
1594      * tested with <code>Node.isSameNode</code>. All nodes that are the same
1595      * will also be equal, though the reverse may not be true.
1596      * <br>Two nodes are equal if and only if the following conditions are
1597      * satisfied: The two nodes are of the same type.The following string
1598      * attributes are equal: <code>nodeName</code>, <code>localName</code>,
1599      * <code>namespaceURI</code>, <code>prefix</code>, <code>nodeValue</code>
1600      * , <code>baseURI</code>. This is: they are both <code>null</code>, or
1601      * they have the same length and are character for character identical.
1602      * The <code>attributes</code> <code>NamedNodeMaps</code> are equal.
1603      * This is: they are both <code>null</code>, or they have the same
1604      * length and for each node that exists in one map there is a node that
1605      * exists in the other map and is equal, although not necessarily at the
1606      * same index.The <code>childNodes</code> <code>NodeLists</code> are
1607      * equal. This is: they are both <code>null</code>, or they have the
1608      * same length and contain equal nodes at the same index. This is true
1609      * for <code>Attr</code> nodes as for any other type of node. Note that
1610      * normalization can affect equality; to avoid this, nodes should be
1611      * normalized before being compared.
1612      * <br>For two <code>DocumentType</code> nodes to be equal, the following
1613      * conditions must also be satisfied: The following string attributes
1614      * are equal: <code>publicId</code>, <code>systemId</code>,
1615      * <code>internalSubset</code>.The <code>entities</code>
1616      * <code>NamedNodeMaps</code> are equal.The <code>notations</code>
1617      * <code>NamedNodeMaps</code> are equal.
1618      * <br>On the other hand, the following do not affect equality: the
1619      * <code>ownerDocument</code> attribute, the <code>specified</code>
1620      * attribute for <code>Attr</code> nodes, the
1621      * <code>isWhitespaceInElementContent</code> attribute for
1622      * <code>Text</code> nodes, as well as any user data or event listeners
1623      * registered on the nodes.
1624      * @param arg The node to compare equality with.
1625      * @param deep If <code>true</code>, recursively compare the subtrees; if
1626      *   <code>false</code>, compare only the nodes themselves (and its
1627      *   attributes, if it is an <code>Element</code>).
1628      * @return If the nodes, and possibly subtrees are equal,
1629      *   <code>true</code> otherwise <code>false</code>.
1630      * @since DOM Level 3
1631      */

1632     public boolean isEqualNode(Node arg) {
1633         if (arg == this) {
1634             return true;
1635         }
1636         if (arg.getNodeType() != getNodeType()) {
1637             return false;
1638         }
1639         // in theory nodeName can't be null but better be careful
1640         // who knows what other implementations may be doing?...
1641         if (getNodeName() == null) {
1642             if (arg.getNodeName() != null) {
1643                 return false;
1644             }
1645         }
1646         else if (!getNodeName().equals(arg.getNodeName())) {
1647             return false;
1648         }
1649 
1650         if (getLocalName() == null) {
1651             if (arg.getLocalName() != null) {
1652                 return false;
1653             }
1654         }
1655         else if (!getLocalName().equals(arg.getLocalName())) {
1656             return false;
1657         }
1658 
1659         if (getNamespaceURI() == null) {
1660             if (arg.getNamespaceURI() != null) {
1661                 return false;
1662             }
1663         }
1664         else if (!getNamespaceURI().equals(arg.getNamespaceURI())) {
1665             return false;
1666         }
1667 
1668         if (getPrefix() == null) {
1669             if (arg.getPrefix() != null) {
1670                 return false;
1671             }
1672         }
1673         else if (!getPrefix().equals(arg.getPrefix())) {
1674             return false;
1675         }
1676 
1677         if (getNodeValue() == null) {
1678             if (arg.getNodeValue() != null) {
1679                 return false;
1680             }
1681         }
1682         else if (!getNodeValue().equals(arg.getNodeValue())) {
1683             return false;
1684         }
1685     /*
1686         if (getBaseURI() == null) {
1687             if (((NodeImpl) arg).getBaseURI() != null) {
1688                 return false;
1689             }
1690         }
1691         else if (!getBaseURI().equals(((NodeImpl) arg).getBaseURI())) {
1692             return false;
1693         }
1694 */
1695 
1696              return true;
1697     }
1698 
1699       /**
1700      * DOM Level 3
1701      * Look up the namespace URI associated to the given prefix, starting from this node.
1702      * Use lookupNamespaceURI(null) to lookup the default namespace
1703      *
1704      * @param namespaceURI
1705      * @return th URI for the namespace
1706      * @since DOM Level 3
1707      */

1708     public String lookupNamespaceURI(String specifiedPrefix) {
1709         short type = this.getNodeType();
1710         switch (type) {
1711         case Node.ELEMENT_NODE : {
1712 
1713                 String namespace = this.getNamespaceURI();
1714                 String prefix = this.getPrefix();
1715                 if (namespace !=null) {
1716                     // REVISIT: is it possible that prefix is empty string?
1717                     if (specifiedPrefix== null && prefix==specifiedPrefix) {
1718                         // looking for default namespace
1719                         return namespace;
1720                     } else if (prefix != null && prefix.equals(specifiedPrefix)) {
1721                         // non default namespace
1722                         return namespace;
1723                     }
1724                 }
1725                 if (this.hasAttributes()) {
1726                     NamedNodeMap map = this.getAttributes();
1727                     int length = map.getLength();
1728                     for (int i=0;i<length;i++) {
1729                         Node attr = map.item(i);
1730                         String attrPrefix = attr.getPrefix();
1731                         String value = attr.getNodeValue();
1732                         namespace = attr.getNamespaceURI();
1733                         if (namespace !=null && namespace.equals("http://www.w3.org/2000/xmlns/")) {
1734                             // at this point we are dealing with DOM Level 2 nodes only
1735                             if (specifiedPrefix == null &&
1736                                 attr.getNodeName().equals("xmlns")) {
1737                                 // default namespace
1738                                 return value;
1739                             } else if (attrPrefix !=null &&
1740                                        attrPrefix.equals("xmlns") &&
1741                                        attr.getLocalName().equals(specifiedPrefix)) {
1742                  // non default namespace
1743                                 return value;
1744                             }
1745                         }
1746                     }
1747                 }
1748                 /*
1749                 NodeImpl ancestor = (NodeImpl)getElementAncestor(this);
1750                 if (ancestor != null) {
1751                     return ancestor.lookupNamespaceURI(specifiedPrefix);
1752                 }
1753                 */
1754 
1755                 return null;
1756 
1757 
1758             }
1759 /*
1760         case Node.DOCUMENT_NODE : {
1761                 return((NodeImpl)((Document)this).getDocumentElement()).lookupNamespaceURI(specifiedPrefix) ;
1762             }
1763 */
1764         case Node.ENTITY_NODE :
1765         case Node.NOTATION_NODE:
1766         case Node.DOCUMENT_FRAGMENT_NODE:
1767         case Node.DOCUMENT_TYPE_NODE:
1768             // type is unknown
1769             return null;
1770         case Node.ATTRIBUTE_NODE:{
1771                 if (this.getOwnerElement().getNodeType() == Node.ELEMENT_NODE) {
1772                     return getOwnerElement().lookupNamespaceURI(specifiedPrefix);
1773 
1774                 }
1775                 return null;
1776             }
1777         default:{
1778            /*
1779                 NodeImpl ancestor = (NodeImpl)getElementAncestor(this);
1780                 if (ancestor != null) {
1781                     return ancestor.lookupNamespaceURI(specifiedPrefix);
1782                 }
1783              */
1784                 return null;
1785             }
1786 
1787         }
1788     }
1789 
1790 
1791     /**
1792      *  DOM Level 3
1793      *  This method checks if the specified <code>namespaceURI</code> is the
1794      *  default namespace or not.
1795      *  @param namespaceURI The namespace URI to look for.
1796      *  @return  <code>true</code> if the specified <code>namespaceURI</code>
1797      *   is the default namespace, <code>false</code> otherwise.
1798      * @since DOM Level 3
1799      */

1800     public boolean isDefaultNamespace(String namespaceURI){
1801        /*
1802         // REVISIT: remove casts when DOM L3 becomes REC.
1803         short type = this.getNodeType();
1804         switch (type) {
1805         case Node.ELEMENT_NODE: {
1806             String namespace = this.getNamespaceURI();
1807             String prefix = this.getPrefix();
1808 
1809             // REVISIT: is it possible that prefix is empty string?
1810             if (prefix == null || prefix.length() == 0) {
1811                 if (namespaceURI == null) {
1812                     return (namespace == namespaceURI);
1813                 }
1814                 return namespaceURI.equals(namespace);
1815             }
1816             if (this.hasAttributes()) {
1817                 ElementImpl elem = (ElementImpl)this;
1818                 NodeImpl attr = (NodeImpl)elem.getAttributeNodeNS("http://www.w3.org/2000/xmlns/", "xmlns");
1819                 if (attr != null) {
1820                     String value = attr.getNodeValue();
1821                     if (namespaceURI == null) {
1822                         return (namespace == value);
1823                     }
1824                     return namespaceURI.equals(value);
1825                 }
1826             }
1827 
1828             NodeImpl ancestor = (NodeImpl)getElementAncestor(this);
1829             if (ancestor != null) {
1830                 return ancestor.isDefaultNamespace(namespaceURI);
1831             }
1832             return false;
1833         }
1834         case Node.DOCUMENT_NODE:{
1835                 return((NodeImpl)((Document)this).getDocumentElement()).isDefaultNamespace(namespaceURI);
1836             }
1837 
1838         case Node.ENTITY_NODE :
1839           case Node.NOTATION_NODE:
1840         case Node.DOCUMENT_FRAGMENT_NODE:
1841         case Node.DOCUMENT_TYPE_NODE:
1842             // type is unknown
1843             return false;
1844         case Node.ATTRIBUTE_NODE:{
1845                 if (this.ownerNode.getNodeType() == Node.ELEMENT_NODE) {
1846                     return ownerNode.isDefaultNamespace(namespaceURI);
1847 
1848                 }
1849                 return false;
1850             }
1851         default:{
1852                 NodeImpl ancestor = (NodeImpl)getElementAncestor(this);
1853                 if (ancestor != null) {
1854                     return ancestor.isDefaultNamespace(namespaceURI);
1855                 }
1856                 return false;
1857             }
1858 
1859         }
1860 */
1861         return false;
1862 
1863 
1864     }
1865 
1866       /**
1867      *
1868      * DOM Level 3
1869      * Look up the prefix associated to the given namespace URI, starting from this node.
1870      *
1871      * @param namespaceURI
1872      * @return the prefix for the namespace
1873      */

1874     public String lookupPrefix(String namespaceURI){
1875 
1876         // REVISIT: When Namespaces 1.1 comes out this may not be true
1877         // Prefix can't be bound to null namespace
1878         if (namespaceURI == null) {
1879             return null;
1880         }
1881 
1882         short type = this.getNodeType();
1883 
1884         switch (type) {
1885 /*
1886         case Node.ELEMENT_NODE: {
1887 
1888                 String namespace = this.getNamespaceURI(); // to flip out children
1889                 return lookupNamespacePrefix(namespaceURI, (ElementImpl)this);
1890             }
1891 
1892         case Node.DOCUMENT_NODE:{
1893                 return((NodeImpl)((Document)this).getDocumentElement()).lookupPrefix(namespaceURI);
1894             }
1895 */
1896         case Node.ENTITY_NODE :
1897         case Node.NOTATION_NODE:
1898         case Node.DOCUMENT_FRAGMENT_NODE:
1899         case Node.DOCUMENT_TYPE_NODE:
1900             // type is unknown
1901             return null;
1902         case Node.ATTRIBUTE_NODE:{
1903                 if (this.getOwnerElement().getNodeType() == Node.ELEMENT_NODE) {
1904                     return getOwnerElement().lookupPrefix(namespaceURI);
1905 
1906                 }
1907                 return null;
1908             }
1909         default:{
1910 /*
1911                 NodeImpl ancestor = (NodeImpl)getElementAncestor(this);
1912                 if (ancestor != null) {
1913                     return ancestor.lookupPrefix(namespaceURI);
1914                 }
1915 */
1916                 return null;
1917             }
1918          }
1919     }
1920 
1921      /**
1922      * Returns whether this node is the same node as the given one.
1923      * <br>This method provides a way to determine whether two
1924      * <code>Node</code> references returned by the implementation reference
1925      * the same object. When two <code>Node</code> references are references
1926      * to the same object, even if through a proxy, the references may be
1927      * used completely interchangably, such that all attributes have the
1928      * same values and calling the same DOM method on either reference
1929      * always has exactly the same effect.
1930      * @param other The node to test against.
1931      * @return Returns <code>true</code> if the nodes are the same,
1932      *   <code>false</code> otherwise.
1933      * @since DOM Level 3
1934      */

1935     public boolean isSameNode(Node other) {
1936         // we do not use any wrapper so the answer is obvious
1937         return this == other;
1938     }
1939 
1940       /**
1941      * This attribute returns the text content of this node and its
1942      * descendants. When it is defined to be null, setting it has no effect.
1943      * When set, any possible children this node may have are removed and
1944      * replaced by a single <code>Text</code> node containing the string
1945      * this attribute is set to. On getting, no serialization is performed,
1946      * the returned string does not contain any markup. No whitespace
1947      * normalization is performed, the returned string does not contain the
1948      * element content whitespaces . Similarly, on setting, no parsing is
1949      * performed either, the input string is taken as pure textual content.
1950      * <br>The string returned is made of the text content of this node
1951      * depending on its type, as defined below:
1952      * <table border='1'>
1953      * <tr>
1954      * <th>Node type</th>
1955      * <th>Content</th>
1956      * </tr>
1957      * <tr>
1958      * <td valign='top' rowspan='1' colspan='1'>
1959      * ELEMENT_NODE, ENTITY_NODE, ENTITY_REFERENCE_NODE,
1960      * DOCUMENT_FRAGMENT_NODE</td>
1961      * <td valign='top' rowspan='1' colspan='1'>concatenation of the <code>textContent</code>
1962      * attribute value of every child node, excluding COMMENT_NODE and
1963      * PROCESSING_INSTRUCTION_NODE nodes</td>
1964      * </tr>
1965      * <tr>
1966      * <td valign='top' rowspan='1' colspan='1'>ATTRIBUTE_NODE, TEXT_NODE,
1967      * CDATA_SECTION_NODE, COMMENT_NODE, PROCESSING_INSTRUCTION_NODE</td>
1968      * <td valign='top' rowspan='1' colspan='1'>
1969      * <code>nodeValue</code></td>
1970      * </tr>
1971      * <tr>
1972      * <td valign='top' rowspan='1' colspan='1'>DOCUMENT_NODE, DOCUMENT_TYPE_NODE, NOTATION_NODE</td>
1973      * <td valign='top' rowspan='1' colspan='1'>
1974      * null</td>
1975      * </tr>
1976      * </table>
1977      * @exception DOMException
1978      *   NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
1979      * @exception DOMException
1980      *   DOMSTRING_SIZE_ERR: Raised when it would return more characters than
1981      *   fit in a <code>DOMString</code> variable on the implementation
1982      *   platform.
1983        * @since DOM Level 3
1984      */

1985     public void setTextContent(String textContent)
1986         throws DOMException {
1987         setNodeValue(textContent);
1988     }
1989     /**
1990      * This attribute returns the text content of this node and its
1991      * descendants. When it is defined to be null, setting it has no effect.
1992      * When set, any possible children this node may have are removed and
1993      * replaced by a single <code>Text</code> node containing the string
1994      * this attribute is set to. On getting, no serialization is performed,
1995      * the returned string does not contain any markup. No whitespace
1996      * normalization is performed, the returned string does not contain the
1997      * element content whitespaces . Similarly, on setting, no parsing is
1998      * performed either, the input string is taken as pure textual content.
1999      * <br>The string returned is made of the text content of this node
2000      * depending on its type, as defined below:
2001      * <table border='1'>
2002      * <tr>
2003      * <th>Node type</th>
2004      * <th>Content</th>
2005      * </tr>
2006      * <tr>
2007      * <td valign='top' rowspan='1' colspan='1'>
2008      * ELEMENT_NODE, ENTITY_NODE, ENTITY_REFERENCE_NODE,
2009      * DOCUMENT_FRAGMENT_NODE</td>
2010      * <td valign='top' rowspan='1' colspan='1'>concatenation of the <code>textContent</code>
2011      * attribute value of every child node, excluding COMMENT_NODE and
2012      * PROCESSING_INSTRUCTION_NODE nodes</td>
2013      * </tr>
2014      * <tr>
2015      * <td valign='top' rowspan='1' colspan='1'>ATTRIBUTE_NODE, TEXT_NODE,
2016      * CDATA_SECTION_NODE, COMMENT_NODE, PROCESSING_INSTRUCTION_NODE</td>
2017      * <td valign='top' rowspan='1' colspan='1'>
2018      * <code>nodeValue</code></td>
2019      * </tr>
2020      * <tr>
2021      * <td valign='top' rowspan='1' colspan='1'>DOCUMENT_NODE, DOCUMENT_TYPE_NODE, NOTATION_NODE</td>
2022      * <td valign='top' rowspan='1' colspan='1'>
2023      * null</td>
2024      * </tr>
2025      * </table>
2026      * @exception DOMException
2027      *   NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
2028      * @exception DOMException
2029      *   DOMSTRING_SIZE_ERR: Raised when it would return more characters than
2030      *   fit in a <code>DOMString</code> variable on the implementation
2031      *   platform.
2032      * @since DOM Level 3
2033      */

2034     public String getTextContent() throws DOMException {
2035         return getNodeValue();  // overriden in some subclasses
2036     }
2037 
2038      /**
2039      * Compares a node with this node with regard to their position in the
2040      * document.
2041      * @param other The node to compare against this node.
2042      * @return Returns how the given node is positioned relatively to this
2043      *   node.
2044      * @since DOM Level 3
2045      */

2046     public short compareDocumentPosition(Node other) throws DOMException {
2047         return 0;
2048     }
2049 
2050      /**
2051      * The absolute base URI of this node or <code>null</code> if undefined.
2052      * This value is computed according to . However, when the
2053      * <code>Document</code> supports the feature "HTML" , the base URI is
2054      * computed using first the value of the href attribute of the HTML BASE
2055      * element if any, and the value of the <code>documentURI</code>
2056      * attribute from the <code>Document</code> interface otherwise.
2057      * <br> When the node is an <code>Element</code>, a <code>Document</code>
2058      * or a a <code>ProcessingInstruction</code>, this attribute represents
2059      * the properties [base URI] defined in . When the node is a
2060      * <code>Notation</code>, an <code>Entity</code>, or an
2061      * <code>EntityReference</code>, this attribute represents the
2062      * properties [declaration base URI] in the . How will this be affected
2063      * by resolution of relative namespace URIs issue?It's not.Should this
2064      * only be on Document, Element, ProcessingInstruction, Entity, and
2065      * Notation nodes, according to the infoset? If not, what is it equal to
2066      * on other nodes? Null? An empty string? I think it should be the
2067      * parent's.No.Should this be read-only and computed or and actual
2068      * read-write attribute?Read-only and computed (F2F 19 Jun 2000 and
2069      * teleconference 30 May 2001).If the base HTML element is not yet
2070      * attached to a document, does the insert change the Document.baseURI?
2071      * Yes. (F2F 26 Sep 2001)
2072      * @since DOM Level 3
2073      */

2074     public String getBaseURI() {
2075         return null;
2076     }
2077 
2078         /**
2079      * DOM Level 3
2080      * Renaming node
2081      */

2082     public Node renameNode(Node n,
2083                            String namespaceURI,
2084                            String name)
2085                            throws DOMException{
2086         return n;
2087     }
2088 
2089 
2090     /**
2091      *  DOM Level 3
2092      *  Normalize document.
2093      */

2094     public void normalizeDocument(){
2095 
2096     }
2097     /**
2098      *  The configuration used when <code>Document.normalizeDocument</code> is
2099      * invoked.
2100      * @since DOM Level 3
2101      */

2102     public DOMConfiguration getDomConfig(){
2103        return null;
2104     }
2105 
2106 
2107     /** DOM Level 3 feature: documentURI */
2108     protected String fDocumentURI;
2109 
2110     /**
2111      * DOM Level 3
2112      */

2113     public void setDocumentURI(String documentURI){
2114 
2115         fDocumentURI= documentURI;
2116     }
2117 
2118         /**
2119      * DOM Level 3
2120      * The location of the document or <code>null</code> if undefined.
2121      * <br>Beware that when the <code>Document</code> supports the feature
2122      * "HTML" , the href attribute of the HTML BASE element takes precedence
2123      * over this attribute.
2124      * @since DOM Level 3
2125      */

2126     public String getDocumentURI(){
2127         return fDocumentURI;
2128     }
2129 
2130         /**DOM Level 3 feature: Document actualEncoding */
2131     protected String actualEncoding;
2132 
2133      /**
2134      * DOM Level 3
2135      * An attribute specifying the actual encoding of this document. This is
2136      * <code>null</code> otherwise.
2137      * <br> This attribute represents the property [character encoding scheme]
2138      * defined in .
2139      * @since DOM Level 3
2140      */
2141     public String getActualEncoding() {
2142         return actualEncoding;
2143     }
2144 
2145     /**
2146      * DOM Level 3
2147      * An attribute specifying the actual encoding of this document. This is
2148      * <code>null</code> otherwise.
2149      * <br> This attribute represents the property [character encoding scheme]
2150      * defined in .
2151      * @since DOM Level 3
2152      */
2153     public void setActualEncoding(String value) {
2154         actualEncoding = value;
2155     }
2156 
2157      /**
2158     * DOM Level 3
2159     */

2160     public Text replaceWholeText(String content)
2161                                  throws DOMException{
2162 /*
2163 
2164         if (needsSyncData()) {
2165             synchronizeData();
2166         }
2167 
2168         // make sure we can make the replacement
2169         if (!canModify(nextSibling)) {
2170             throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR,
2171                 DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "NO_MODIFICATION_ALLOWED_ERR", null));
2172         }
2173 
2174         Node parent = this.getParentNode();
2175         if (content == null || content.length() == 0) {
2176             // remove current node
2177             if (parent !=null) { // check if node in the tree
2178                 parent.removeChild(this);
2179                 return null;
2180             }
2181         }
2182         Text currentNode = null;
2183         if (isReadOnly()){
2184             Text newNode = this.ownerDocument().createTextNode(content);
2185             if (parent !=null) { // check if node in the tree
2186                 parent.insertBefore(newNode, this);
2187                 parent.removeChild(this);
2188                 currentNode = newNode;
2189             } else {
2190                 return newNode;
2191             }
2192         }  else {
2193             this.setData(content);
2194             currentNode = this;
2195         }
2196         Node sibling =  currentNode.getNextSibling();
2197         while ( sibling !=null) {
2198             parent.removeChild(sibling);
2199             sibling = currentNode.getNextSibling();
2200         }
2201 
2202         return currentNode;
2203 */
2204         return null; //Pending
2205     }
2206 
2207      /**
2208      * DOM Level 3
2209      * Returns all text of <code>Text</code> nodes logically-adjacent text
2210      * nodes to this node, concatenated in document order.
2211      * @since DOM Level 3
2212      */

2213     public String getWholeText(){
2214 
2215 /*
2216         if (needsSyncData()) {
2217             synchronizeData();
2218         }
2219         if (nextSibling == null) {
2220             return data;
2221         }
2222         StringBuffer buffer = new StringBuffer();
2223         if (data != null && data.length() != 0) {
2224             buffer.append(data);
2225         }
2226         getWholeText(nextSibling, buffer);
2227         return buffer.toString();
2228 */
2229         return null; // PENDING
2230 
2231     }
2232 
2233       /**
2234     * DOM Level 3
2235      * Returns whether this text node contains whitespace in element content,
2236      * often abusively called "ignorable whitespace".
2237      */

2238     public boolean isElementContentWhitespace(){
2239         return false;
2240     }
2241 
2242 
2243 
2244 
2245      /**
2246      * NON-DOM: set the type of this attribute to be ID type.
2247      *
2248      * @param id
2249      */
2250     public void setIdAttribute(boolean id){
2251         //PENDING
2252     }
2253 
2254      /**
2255      * DOM Level 3: register the given attribute node as an ID attribute
2256      */

2257     public void setIdAttribute(String name, boolean makeId) {
2258         //PENDING
2259     }
2260 
2261 
2262     /**
2263      * DOM Level 3: register the given attribute node as an ID attribute
2264      */

2265     public void setIdAttributeNode(Attr at, boolean makeId) {
2266         //PENDING
2267     }
2268 
2269     /**
2270      * DOM Level 3: register the given attribute node as an ID attribute
2271      */

2272     public void setIdAttributeNS(String namespaceURI, String localName,
2273                                     boolean makeId) {
2274         //PENDING
2275     }
2276          /**
2277          * Method getSchemaTypeInfo.
2278          * @return TypeInfo
2279          */

2280     public TypeInfo getSchemaTypeInfo(){
2281       return null; //PENDING
2282     }
2283 

2284     public boolean isId() {
2285         return false; //PENDING
2286     }
2287 
2288 
2289     private String xmlEncoding;

2290     public String getXmlEncoding( ) {
2291         return xmlEncoding;
2292     }
2293     public void setXmlEncoding( String xmlEncoding ) {
2294         this.xmlEncoding = xmlEncoding;
2295     }
2296 
2297     private boolean xmlStandalone;

2298     public boolean getXmlStandalone() {
2299         return xmlStandalone;
2300     }
2301 

2302     public void setXmlStandalone(boolean xmlStandalone) throws DOMException {
2303         this.xmlStandalone = xmlStandalone;
2304     }
2305 
2306     private String xmlVersion;

2307     public String getXmlVersion() {
2308         return xmlVersion;
2309     }
2310 

2311     public void setXmlVersion(String xmlVersion) throws DOMException {
2312         this.xmlVersion = xmlVersion;
2313     }
2314 
2315 
2316 
2317 }
--- EOF ---