src/dom/dom.h

   1 #ifndef __DOM_H__
   2 #define __DOM_H__
   3 /**
   4  * Phoebe DOM Implementation.
   5  *
   6  * This is a C++ approximation of the W3C DOM model, which follows
   7  * fairly closely the specifications in the various .idl files, copies of
   8  * which are provided for reference.  Most important is this one:
   9  *
  10  * http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/idl-definitions.html
  11  *
  12  * Authors:
  13  *   Bob Jamison
  14  *
  15  * Copyright (C) 2006 Bob Jamison
  16  *
  17  *  This library is free software; you can redistribute it and/or
  18  *  modify it under the terms of the GNU Lesser General Public
  19  *  License as published by the Free Software Foundation; either
  20  *  version 2.1 of the License, or (at your option) any later version.
  21  *
  22  *  This library is distributed in the hope that it will be useful,
  23  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  24  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  25  *  Lesser General Public License for more details.
  26  *
  27  *  You should have received a copy of the GNU Lesser General Public
  28  *  License along with this library; if not, write to the Free Software
  29  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  30  */
  31
  32 #include <vector>
  33
  34 //# include this before the #ifdefs below
  35 #include "domconfig.h"
  36
  37 #ifdef DOM_STRING_OWN
  38 #include "domstring.h"
  39 #else
  40 #ifdef DOM_STRING_GLIBMM
  41 #include <glibmm.h>
  42 #else
  43 #include <string>
  44 #endif
  45 #endif
  46
  47 //# Unfortunate hack for a name collision
  48 #ifdef SEVERITY_ERROR
  49 #undef SEVERITY_ERROR
  50 #endif
  51
  52 #define XMLNSNAME "http://www.w3.org/2000/xmlns/"
  53
  54 namespace org
  55 {
  56 namespace w3c
  57 {
  58 namespace dom
  59 {
  60
  61
  62
  63 #ifdef DOM_STRING_OWN
  64 #else
  65 #ifdef DOM_STRING_GLIBMM
  66 typedef Glib::ustring DOMString;
  67 typedef gunichar XMLCh;
  68 #else
  69 typedef std::string DOMString;
  70 typedef unsigned short XMLCh;
  71 #endif
  72 #endif
  73
  74
  75 /**
  76  *
  77  */
  78 typedef unsigned long long DOMTimeStamp;
  79
  80 /**
  81  *
  82  */
  83 typedef void DOMUserData;
  84
  85 /*#########################################################################
  86 ## NodePtr
  87 #########################################################################*/
  88
  89 /**
  90  * A simple Smart Pointer class that handles Nodes and all of its
  91  * descendants
  92  */
  93 template<class T> class Ptr
  94 {
  95 public:
  96
  97     /**
  98      * Simple constructor
  99      */
 100     Ptr()
 101         { _ref = 0; }
 102
 103     /**
 104      * Constructor upon a reference
 105      */
 106     template<class Y> Ptr(const Ptr<Y> &other)
 107         {
 108         _ref = other._ref;
 109             incrementRefCount(_ref);
 110         }
 111
 112     /**
 113      * Constructor upon a reference
 114      */
 115     Ptr(T * refArg, bool addRef = true)
 116         {
 117         _ref = refArg;
 118         if(addRef)
 119                     incrementRefCount(_ref);
 120         }
 121
 122
 123     /**
 124      * Copy constructor
 125      */
 126     Ptr(const Ptr &other)
 127         {
 128         _ref = other._ref;
 129             incrementRefCount(_ref);
 130         }
 131
 132     /**
 133      * Destructor
 134      */
 135     ~Ptr()
 136         {
 137             decrementRefCount(_ref);
 138         }
 139
 140
 141     /**
 142      * Assignment operator
 143      */
 144     template<class Y> Ptr &operator=(const Ptr<Y> &other)
 145         {
 146         decrementRefCount(_ref);
 147         _ref = other._ref;
 148         incrementRefCount(_ref);
 149         return *this;
 150         }
 151
 152     /**
 153      * Assignment operator
 154      */
 155     Ptr &operator=(const Ptr &other)
 156         {
 157         decrementRefCount(_ref);
 158         _ref = other._ref;
 159         incrementRefCount(_ref);
 160         return *this;
 161         }
 162
 163     /**
 164      * Assignment operator
 165      */
 166     template<class Y> Ptr &operator=(Y * ref)
 167         {
 168         decrementRefCount(_ref);
 169         _ref = ref;
 170         incrementRefCount(_ref);
 171         return *this;
 172         }
 173
 174     /**
 175      * Assignment operator
 176      */
 177     template<class Y> Ptr &operator=(const Y * ref)
 178         {
 179         decrementRefCount(_ref);
 180         _ref = (Y *) ref;
 181         incrementRefCount(_ref);
 182         return *this;
 183         }
 184
 185     /**
 186      * Return the reference
 187      */
 188     T * get() const
 189         {
 190         return _ref;
 191         }
 192
 193     /**
 194      * Dereference operator
 195      */
 196     T &operator*() const
 197         {
 198         return *_ref;
 199         }
 200
 201     /**
 202      * Point-to operator
 203      */
 204     T *operator->() const
 205         {
 206         return _ref;
 207         }
 208
 209     /**
 210      * NOT bool operator.  How to check if we are null without a comparison
 211      */
 212     bool operator! () const
 213         {
 214         return (_ref == 0);
 215         }
 216
 217     /**
 218      * Swap what I reference with the other guy
 219      */
 220     void swap(Ptr &other)
 221         {
 222         T *tmp = _ref;
 223         _ref = other._ref;
 224         other._ref = tmp;
 225         }
 226
 227     //The referenced item
 228     T *_ref;
 229 };
 230
 231
 232 /**
 233  * Global definitions.  Many of these are used to mimic behaviour of
 234  * a real pointer
 235  */
 236
 237 /**
 238  * Equality
 239  */
 240 template<class T, class U> inline bool
 241    operator==(const Ptr<T> &a, const Ptr<U> &b)
 242 {
 243     return a.get() == b.get();
 244 }
 245
 246 /**
 247  * Inequality
 248  */
 249 template<class T, class U> inline bool
 250      operator!=(const Ptr<T> &a, const Ptr<U> &b)
 251 {
 252     return a.get() != b.get();
 253 }
 254
 255 /**
 256  * Equality
 257  */
 258 template<class T> inline bool
 259      operator==(const Ptr<T> &a, T * b)
 260 {
 261     return a.get() == b;
 262 }
 263
 264 /**
 265  * Inequality
 266  */
 267 template<class T> inline bool
 268      operator!=(const Ptr<T> &a, T * b)
 269 {
 270     return a.get() != b;
 271 }
 272
 273 /**
 274  * Equality
 275  */
 276 template<class T> inline bool
 277      operator==(T * a, const Ptr<T> &b)
 278 {
 279     return a == b.get();
 280 }
 281
 282 /**
 283  * Inequality
 284  */
 285 template<class T> inline bool
 286      operator!=(T * a, const Ptr<T> &b)
 287 {
 288     return a != b.get();
 289 }
 290
 291
 292 /**
 293  * Less than
 294  */
 295 template<class T> inline bool
 296      operator<(const Ptr<T> &a, const Ptr<T> &b)
 297 {
 298     return std::less<T *>()(a.get(), b.get());
 299 }
 300
 301 /**
 302  * Swap
 303  */
 304 template<class T> void
 305      swap(Ptr<T> &a, Ptr<T> &b)
 306 {
 307     a.swap(b);
 308 }
 309
 310
 311 /**
 312  * Get the pointer globally, for <algo>
 313  */
 314 template<class T> T *
 315     get_pointer(const Ptr<T> &p)
 316 {
 317     return p.get();
 318 }
 319
 320 /**
 321  * Static cast
 322  */
 323 template<class T, class U> Ptr<T>
 324      static_pointer_cast(const Ptr<U> &p)
 325 {
 326     return static_cast<T *>(p.get());
 327 }
 328
 329 /**
 330  * Const cast
 331  */
 332 template<class T, class U> Ptr<T>
 333      const_pointer_cast(const Ptr<U> &p)
 334 {
 335     return const_cast<T *>(p.get());
 336 }
 337
 338 /**
 339  * Dynamic cast
 340  */
 341 template<class T, class U> Ptr<T>
 342      dynamic_pointer_cast(const Ptr<U> &p)
 343 {
 344     return dynamic_cast<T *>(p.get());
 345 }
 346
 347
 348 /**
 349  *
 350  */
 351 typedef void DOMObject;
 352
 353
 354 class NodeList;
 355 class NamedNodeMap;
 356 class DOMException;
 357 class DOMStringList;
 358 class NameList;
 359 class DOMImplementationList;
 360 class DOMImplementationSource;
 361 class DOMImplementation;
 362 class TypeInfo;
 363 class UserDataHandler;
 364 class DOMError;
 365 class DOMErrorHandler;
 366 class DOMLocator;
 367 class DOMConfiguration;
 368
 369 class Node;
 370 typedef Ptr<Node> NodePtr;
 371 class CharacterData;
 372 typedef Ptr<CharacterData> CharacterDataPtr;
 373 class Attr;
 374 typedef Ptr<Attr> AttrPtr;
 375 class Element;
 376 typedef Ptr<Element> ElementPtr;
 377 class Text;
 378 typedef Ptr<Text> TextPtr;
 379 class Comment;
 380 typedef Ptr<Comment> CommentPtr;
 381 class DocumentType;
 382 typedef Ptr<DocumentType> DocumentTypePtr;
 383 class CDATASection;
 384 typedef Ptr<CDATASection> CDATASectionPtr;
 385 class Notation;
 386 typedef Ptr<Notation> NotationPtr;
 387 class Entity;
 388 typedef Ptr<Entity> EntityPtr;
 389 class EntityReference;
 390 typedef Ptr<EntityReference> EntityReferencePtr;
 391 class ProcessingInstruction;
 392 typedef Ptr<ProcessingInstruction> ProcessingInstructionPtr;
 393 class DocumentFragment;
 394 typedef Ptr<DocumentFragment> DocumentFragmentPtr;
 395 class Document;
 396 typedef Ptr<Document> DocumentPtr;
 397
 398
 399
 400
 401 /**
 402  * NOTE: We were originally intending to split ALL specifications into
 403  * interface and implementation.   After consideration, though, it behooves
 404  * us to simplify things by implementing the base exception and
 405  * container classes directly:
 406  *
 407  * DOMException
 408  * DOMStringList
 409  * NameList
 410  * DOMImplementationList
 411  * DOMImplementationSource
 412  * DOMImplementation
 413  * NodeList
 414  * NamedNodeMap
 415  */
 416
 417
 418 /*#########################################################################
 419 ## DOMException
 420 #########################################################################*/
 421 /**
 422  *  This is the only non-interface class
 423  */
 424 class DOMException
 425 {
 426
 427 public:
 428
 429     /**
 430      * ExceptionCode
 431      */
 432     typedef enum
 433         {
 434         INDEX_SIZE_ERR                 = 1,
 435         DOMSTRING_SIZE_ERR             = 2,
 436         HIERARCHY_REQUEST_ERR          = 3,
 437         WRONG_DOCUMENT_ERR             = 4,
 438         INVALID_CHARACTER_ERR          = 5,
 439         NO_DATA_ALLOWED_ERR            = 6,
 440         NO_MODIFICATION_ALLOWED_ERR    = 7,
 441         NOT_FOUND_ERR                  = 8,
 442         NOT_SUPPORTED_ERR              = 9,
 443         INUSE_ATTRIBUTE_ERR            = 10,
 444         INVALID_STATE_ERR              = 11,
 445         SYNTAX_ERR                     = 12,
 446         INVALID_MODIFICATION_ERR       = 13,
 447         NAMESPACE_ERR                  = 14,
 448         INVALID_ACCESS_ERR             = 15,
 449         VALIDATION_ERR                 = 16,
 450         TYPE_MISMATCH_ERR              = 17
 451         } ExceptionCode;
 452
 453
 454
 455     DOMException(const DOMString &reasonMsg)
 456         { msg = reasonMsg; }
 457
 458     DOMException(short theCode)
 459         {
 460         code = theCode;
 461         }
 462
 463     virtual ~DOMException() throw()
 464        {}
 465
 466     /**
 467      *
 468      */
 469     unsigned short code;
 470
 471     /**
 472      *
 473      */
 474     DOMString msg;
 475
 476     /**
 477      * Get a string, translated from the code.
 478      * Like std::exception. Not in spec.
 479      */
 480     const char *what()
 481         { return (const char *)msg.c_str(); }
 482
 483
 484
 485 };
 486
 487
 488
 489
 490
 491
 492 /*#########################################################################
 493 ## DOMStringList
 494 #########################################################################*/
 495
 496 class DOMStringList
 497 {
 498 public:
 499
 500     /**
 501      *
 502      */
 503     virtual DOMString item(unsigned long index)
 504         {
 505         if (index>=strings.size())
 506             return "";
 507         return strings[index];
 508         }
 509
 510     /**
 511      *
 512      */
 513     virtual unsigned long getLength()
 514         {
 515         return (unsigned long) strings.size();
 516         }
 517
 518     /**
 519      *
 520      */
 521     virtual bool contains(const DOMString &str)
 522         {
 523         for (unsigned int i=0; i<strings.size() ; i++)
 524             {
 525             if (strings[i] == str)
 526                 return true;
 527             }
 528         return false;
 529         }
 530
 531
 532     //##################
 533     //# Non-API methods
 534     //##################
 535
 536     /**
 537      *
 538      */
 539     DOMStringList() {}
 540
 541
 542     /**
 543      *
 544      */
 545     DOMStringList(const DOMStringList &other)
 546         {
 547         strings = other.strings;
 548         }
 549
 550     /**
 551      *
 552      */
 553     DOMStringList &operator=(const DOMStringList &other)
 554         {
 555         strings = other.strings;
 556         return *this;
 557         }
 558
 559     /**
 560      *
 561      */
 562     virtual ~DOMStringList() {}
 563
 564
 565 protected:
 566
 567     /**
 568      *
 569      */
 570     virtual void add(const DOMString &str)
 571         {
 572         strings.push_back(str);
 573         }
 574
 575     std::vector<DOMString>strings;
 576
 577 };
 578
 579
 580
 581 /*#########################################################################
 582 ## NameList
 583 #########################################################################*/
 584 class NamePair
 585 {
 586 public:
 587     NamePair(const DOMString &theNamespaceURI, const DOMString &theName)
 588         {
 589         namespaceURI = theNamespaceURI;
 590         name         = theName;
 591         }
 592     NamePair(const NamePair &other)
 593         {
 594         namespaceURI = other.namespaceURI;
 595         name         = other.name;
 596         }
 597     NamePair &operator=(const NamePair &other)
 598         {
 599         namespaceURI = other.namespaceURI;
 600         name         = other.name;
 601         return *this;
 602         }
 603     virtual ~NamePair() {}
 604
 605     DOMString namespaceURI;
 606     DOMString name;
 607 };
 608
 609
 610
 611 class NameList
 612 {
 613 public:
 614
 615     /**
 616      *
 617      */
 618     virtual DOMString getName(unsigned long index)
 619         {
 620         if (index>=namePairs.size())
 621             return "";
 622         return namePairs[index].name;
 623         }
 624
 625     /**
 626      *
 627      */
 628     virtual DOMString getNamespaceURI(unsigned long index)
 629         {
 630         if (index>=namePairs.size())
 631             return "";
 632         return namePairs[index].namespaceURI;
 633         }
 634
 635     /**
 636      *
 637      */
 638     virtual unsigned long getLength()
 639         {
 640         return (unsigned long)namePairs.size();
 641         }
 642
 643     /**
 644      *
 645      */
 646     virtual bool contains(const DOMString &name)
 647         {
 648         for (unsigned int i=0; i<namePairs.size() ; i++)
 649             {
 650             if (namePairs[i].name == name )
 651                 return true;
 652             }
 653         return false;
 654         }
 655
 656     /**
 657      *
 658      */
 659     virtual bool containsNS(const DOMString namespaceURI,const DOMString &name)
 660         {
 661         for (unsigned int i=0; i<namePairs.size() ; i++)
 662             {
 663             if (namePairs[i].namespaceURI == namespaceURI ||
 664                 namePairs[i].name         == name           )
 665                 return true;
 666             }
 667         return false;
 668         }
 669
 670
 671     //##################
 672     //# Non-API methods
 673     //##################
 674
 675     /**
 676      *
 677      */
 678     NameList() {}
 679
 680     /**
 681      *
 682      */
 683     NameList(const NameList &other)
 684         {
 685         namePairs = other.namePairs;
 686         }
 687
 688     /**
 689      *
 690      */
 691     NameList &operator=(const NameList &other)
 692         {
 693         namePairs = other.namePairs;
 694         return *this;
 695         }
 696
 697     /**
 698      *
 699      */
 700     virtual ~NameList() {}
 701 protected:
 702
 703     std::vector<NamePair> namePairs;
 704
 705 };
 706
 707 /*#########################################################################
 708 ## DOMImplementationList
 709 #########################################################################*/
 710
 711 class DOMImplementationList
 712 {
 713 public:
 714
 715     /**
 716      *
 717      */
 718     virtual DOMImplementation *item(unsigned long index)
 719         {
 720         if (index >implementations.size())
 721             return NULL;
 722         return implementations[index];
 723         }
 724
 725     /**
 726      *
 727      */
 728     virtual unsigned long getLength()
 729         {
 730         return (unsigned long) implementations.size();
 731         }
 732
 733
 734
 735
 736     //##################
 737     //# Non-API methods
 738     //##################
 739
 740     /**
 741      *
 742      */
 743     DOMImplementationList() {}
 744
 745
 746     /**
 747      *
 748      */
 749     DOMImplementationList(const DOMImplementationList &other)
 750         {
 751         implementations = other.implementations;
 752         }
 753
 754     /**
 755      *
 756      */
 757     DOMImplementationList &operator=(const DOMImplementationList &other)
 758         {
 759         implementations = other.implementations;
 760         return *this;
 761         }
 762
 763     /**
 764      *
 765      */
 766     virtual ~DOMImplementationList() {}
 767
 768 protected:
 769
 770     std::vector<DOMImplementation *>implementations;
 771
 772 };
 773
 774
 775 /*#########################################################################
 776 ## DOMImplementationSource
 777 #########################################################################*/
 778
 779 class DOMImplementationSource
 780 {
 781 public:
 782
 783     /**
 784      *
 785      */
 786     virtual DOMImplementation *getDOMImplementation(const DOMString &features) = 0;
 787
 788     /**
 789      *
 790      */
 791     virtual DOMImplementationList getDOMImplementationList(const DOMString &features) = 0;
 792
 793     //##################
 794     //# Non-API methods
 795     //##################
 796
 797     /**
 798      *
 799      */
 800     virtual ~DOMImplementationSource() {}
 801
 802 };
 803
 804
 805
 806
 807
 808 /*#########################################################################
 809 ## DOMImplementation
 810 #########################################################################*/
 811 /**
 812  *
 813  */
 814 class DOMImplementation
 815 {
 816 public:
 817     /**
 818      *
 819      */
 820     virtual bool hasFeature(const DOMString& feature, const DOMString& version) = 0;
 821
 822
 823     /**
 824      *
 825      */
 826     virtual DocumentTypePtr createDocumentType(
 827                                        const DOMString& qualifiedName,
 828                                    const DOMString& publicId,
 829                                    const DOMString& systemId)
 830                                    throw(DOMException) = 0;
 831
 832     /**
 833      *
 834      */
 835     virtual DocumentPtr createDocument(const DOMString& namespaceURI,
 836                              const DOMString& qualifiedName,
 837                              DocumentTypePtr doctype)
 838                              throw(DOMException) = 0;
 839     /**
 840      *
 841      */
 842     virtual DOMObject *getFeature(const DOMString& feature,
 843                              const DOMString& version) = 0;
 844
 845
 846     //##################
 847     //# Non-API methods
 848     //##################
 849
 850     /**
 851      *
 852      */
 853     virtual ~DOMImplementation() {}
 854
 855 };
 856
 857
 858
 859
 860
 861 /*#########################################################################
 862 ## Node
 863 #########################################################################*/
 864
 865 /**
 866  *  The basic Node class, which is the root of most other
 867  *  classes in DOM.
 868  */
 869 class Node
 870 {
 871 public:
 872
 873     typedef enum
 874         {
 875         ELEMENT_NODE                   = 1,
 876         ATTRIBUTE_NODE                 = 2,
 877         TEXT_NODE                      = 3,
 878         CDATA_SECTION_NODE             = 4,
 879         ENTITY_REFERENCE_NODE          = 5,
 880         ENTITY_NODE                    = 6,
 881         PROCESSING_INSTRUCTION_NODE    = 7,
 882         COMMENT_NODE                   = 8,
 883         DOCUMENT_NODE                  = 9,
 884         DOCUMENT_TYPE_NODE             = 10,
 885         DOCUMENT_FRAGMENT_NODE         = 11,
 886         NOTATION_NODE                  = 12
 887         } NodeType;
 888
 889     /**
 890      *
 891      */
 892     virtual DOMString getNodeName() = 0;
 893
 894     /**
 895      *
 896      */
 897     virtual DOMString getNodeValue() throw (DOMException) = 0;
 898
 899     /**
 900      *
 901      */
 902     virtual void setNodeValue(const DOMString& val) throw (DOMException) = 0;
 903
 904     /**
 905      *
 906      */
 907     virtual unsigned short getNodeType() = 0;
 908
 909     /**
 910      *
 911      */
 912     virtual NodePtr getParentNode() = 0;
 913
 914     /**
 915      *
 916      */
 917     virtual NodeList getChildNodes() = 0;
 918
 919     /**
 920      *
 921      */
 922     virtual NodePtr getFirstChild() = 0;
 923
 924     /**
 925      *
 926      */
 927     virtual NodePtr getLastChild() = 0;
 928
 929     /**
 930      *
 931      */
 932     virtual NodePtr getPreviousSibling() = 0;
 933
 934     /**
 935      *
 936      */
 937     virtual NodePtr getNextSibling() = 0;
 938
 939     /**
 940      *
 941      */
 942     virtual NamedNodeMap &getAttributes() = 0;
 943
 944
 945     /**
 946      *
 947      */
 948     virtual DocumentPtr getOwnerDocument() = 0;
 949
 950     /**
 951      *
 952      */
 953     virtual NodePtr insertBefore(const NodePtr newChild,
 954                        const NodePtr refChild)
 955                        throw(DOMException) = 0;
 956
 957     /**
 958      *
 959      */
 960     virtual NodePtr replaceChild(const NodePtr newChild,
 961                        const NodePtr oldChild)
 962                        throw(DOMException) = 0;
 963
 964     /**
 965      *
 966      */
 967     virtual NodePtr removeChild(const NodePtr oldChild)
 968                       throw(DOMException) = 0;
 969
 970     /**
 971      *
 972      */
 973     virtual NodePtr appendChild(const NodePtr newChild)
 974                       throw(DOMException) = 0;
 975
 976     /**
 977      *
 978      */
 979     virtual bool hasChildNodes() = 0;
 980
 981     /**
 982      *
 983      */
 984     virtual NodePtr cloneNode(bool deep) = 0;
 985
 986     /**
 987      *
 988      */
 989     virtual void normalize() = 0;
 990
 991     /**
 992      *
 993      */
 994     virtual bool isSupported(const DOMString& feature,
 995                      const DOMString& version) = 0;
 996
 997     /**
 998      *
 999      */
1000     virtual DOMString getNamespaceURI() = 0;
1001
1002     /**
1003      *
1004      */
1005     virtual DOMString getPrefix() = 0;
1006
1007     /**
1008      *
1009      */
1010     virtual void setPrefix(const DOMString& val) throw(DOMException) = 0;
1011
1012     /**
1013      *
1014      */
1015     virtual DOMString getLocalName() = 0;
1016
1017     /**
1018      *
1019      */
1020     virtual bool hasAttributes() = 0;
1021
1022     /**
1023      *
1024      */
1025     virtual DOMString getBaseURI() = 0;
1026
1027     typedef enum
1028         {
1029         DOCUMENT_POSITION_DISCONNECTED            = 0x01,
1030         DOCUMENT_POSITION_PRECEDING               = 0x02,
1031         DOCUMENT_POSITION_FOLLOWING               = 0x04,
1032         DOCUMENT_POSITION_CONTAINS                = 0x08,
1033         DOCUMENT_POSITION_CONTAINED_BY            = 0x10,
1034         DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 0x20
1035         } DocumentPosition;
1036
1037
1038     /**
1039      *
1040      */
1041     virtual unsigned short compareDocumentPosition(
1042                                  const NodePtr other) = 0;
1043
1044     /**
1045      *
1046      */
1047     virtual DOMString getTextContent() throw(DOMException) = 0;
1048
1049
1050     /**
1051      *
1052      */
1053     virtual void setTextContent(const DOMString &val) throw(DOMException) = 0;
1054
1055
1056     /**
1057      *
1058      */
1059     virtual DOMString lookupPrefix(const DOMString &namespaceURI) =0;
1060
1061
1062     /**
1063      *
1064      */
1065     virtual bool isDefaultNamespace(const DOMString &namespaceURI) =0;
1066
1067
1068     /**
1069      *
1070      */
1071     virtual DOMString lookupNamespaceURI(const DOMString &prefix) =0;
1072
1073
1074     /**
1075      *
1076      */
1077     virtual bool isEqualNode(const NodePtr node) =0;
1078
1079
1080
1081     /**
1082      *
1083      */
1084     virtual DOMObject *getFeature(const DOMString &feature,
1085                                  const DOMString &version) =0;
1086
1087     /**
1088      *
1089      */
1090     virtual DOMUserData *setUserData(const DOMString &key,
1091                                      const DOMUserData *data,
1092                                      const UserDataHandler *handler) =0;
1093
1094
1095     /**
1096      *
1097      */
1098     virtual DOMUserData *getUserData(const DOMString &namespaceURI) =0;
1099
1100     //##################
1101     //# Non-API methods
1102     //##################
1103
1104     /**
1105      *
1106      */
1107     Node() : _refCnt(0)
1108         {}
1109
1110     /**
1111      *
1112      */
1113     virtual ~Node() {}
1114
1115 protected:
1116
1117     friend void incrementRefCount(Node *p);
1118     friend void decrementRefCount(Node *p);
1119
1120     /**
1121      * For the Ptr smart pointer
1122      */
1123     int _refCnt;
1124
1125 };
1126
1127
1128
1129
1130 /*#########################################################################
1131 ## NodeList
1132 #########################################################################*/
1133
1134 /**
1135  *
1136  */
1137 class NodeList
1138 {
1139 public:
1140     /**
1141      *
1142      */
1143     virtual NodePtr item(unsigned long index)
1144         {
1145         if (index>=nodes.size())
1146             return NULL;
1147         return nodes[index];
1148         }
1149
1150     /**
1151      *
1152      */
1153     virtual unsigned long getLength()
1154         {
1155         return (unsigned long) nodes.size();
1156         }
1157
1158     //##################
1159     //# Non-API methods
1160     //##################
1161
1162
1163     /**
1164      *
1165      */
1166     NodeList() {}
1167
1168     /**
1169      *
1170      */
1171     NodeList(const NodeList &other)
1172         {
1173         nodes = other.nodes;
1174         }
1175
1176     /**
1177      *
1178      */
1179     NodeList &operator=(const NodeList &other)
1180         {
1181         nodes = other.nodes;
1182         return *this;
1183         }
1184
1185     /**
1186      *
1187      */
1188     virtual ~NodeList() {}
1189
1190     /**
1191      *
1192      */
1193     virtual void clear()
1194         {
1195         nodes.clear();
1196         }
1197
1198 protected:
1199
1200 friend class NodeImpl;
1201 friend class ElementImpl;
1202
1203     /*
1204      *
1205      */
1206     virtual void add(const NodePtr node)
1207         {
1208         nodes.push_back(node);
1209         }
1210
1211 protected:
1212
1213     std::vector<NodePtr> nodes;
1214
1215 };
1216
1217
1218
1219
1220 /*#########################################################################
1221 ## NamedNodeMap
1222 #########################################################################*/
1223
1224 class NamedNodeMapEntry
1225 {
1226 public:
1227     NamedNodeMapEntry(const DOMString &theNamespaceURI,
1228                       const DOMString &theName,
1229                       const NodePtr   theNode)
1230         {
1231         namespaceURI = theNamespaceURI;
1232         name         = theName;
1233         node         = theNode;
1234         }
1235     NamedNodeMapEntry(const NamedNodeMapEntry &other)
1236         {
1237         assign(other);
1238         }
1239     NamedNodeMapEntry &operator=(const NamedNodeMapEntry &other)
1240         {
1241         assign(other);
1242         return *this;
1243         }
1244     virtual ~NamedNodeMapEntry()
1245         {
1246         }
1247     void assign(const NamedNodeMapEntry &other)
1248         {
1249         namespaceURI = other.namespaceURI;
1250         name         = other.name;
1251         node         = other.node;
1252         }
1253     DOMString namespaceURI;
1254     DOMString name;
1255     NodePtr   node;
1256 };
1257
1258 /**
1259  *
1260  */
1261 class NamedNodeMap
1262 {
1263 public:
1264
1265     /**
1266      *
1267      */
1268     virtual NodePtr getNamedItem(const DOMString& name)
1269         {
1270         std::vector<NamedNodeMapEntry>::iterator iter;
1271         for (iter = entries.begin() ; iter!=entries.end() ; iter++)
1272             {
1273             if (iter->name == name)
1274                 {
1275                 NodePtr node = iter->node;
1276                 return node;
1277                 }
1278             }
1279         return NULL;
1280         }
1281
1282     /**
1283      *
1284      */
1285     virtual NodePtr setNamedItem(NodePtr arg) throw(DOMException)
1286         {
1287         if (!arg)
1288             return NULL;
1289         DOMString namespaceURI = arg->getNamespaceURI();
1290         DOMString name         = arg->getNodeName();
1291         std::vector<NamedNodeMapEntry>::iterator iter;
1292         for (iter = entries.begin() ; iter!=entries.end() ; iter++)
1293             {
1294             if (iter->name == name)
1295                 {
1296                 NodePtr node = iter->node;
1297                 iter->node = arg;
1298                 return node;
1299                 }
1300             }
1301         NamedNodeMapEntry entry(namespaceURI, name, arg);
1302         entries.push_back(entry);
1303         return arg;
1304         }
1305
1306
1307     /**
1308      *
1309      */
1310     virtual NodePtr removeNamedItem(const DOMString& name) throw(DOMException)
1311         {
1312         std::vector<NamedNodeMapEntry>::iterator iter;
1313         for (iter = entries.begin() ; iter!=entries.end() ; iter++)
1314             {
1315             if (iter->name == name)
1316                 {
1317                 NodePtr node = iter->node;
1318                 entries.erase(iter);
1319                 return node;
1320                 }
1321             }
1322         return NULL;
1323         }
1324
1325     /**
1326      *
1327      */
1328     virtual NodePtr item(unsigned long index)
1329         {
1330         if (index>=entries.size())
1331             return NULL;
1332         return entries[index].node;
1333         }
1334
1335     /**
1336      *
1337      */
1338     virtual unsigned long getLength()
1339         {
1340         return (unsigned long)entries.size();
1341         }
1342
1343     /**
1344      *
1345      */
1346     virtual NodePtr getNamedItemNS(const DOMString& namespaceURI,
1347                                  const DOMString& localName)
1348         {
1349         std::vector<NamedNodeMapEntry>::iterator iter;
1350         for (iter = entries.begin() ; iter!=entries.end() ; iter++)
1351             {
1352             if (iter->namespaceURI == namespaceURI && iter->name == localName)
1353                 {
1354                 NodePtr node = iter->node;
1355                 return node;
1356                 }
1357             }
1358         return NULL;
1359         }
1360
1361     /**
1362      *
1363      */
1364     virtual NodePtr setNamedItemNS(NodePtr arg) throw(DOMException)
1365         {
1366         if (!arg)
1367             return NULL;
1368         DOMString namespaceURI = arg->getNamespaceURI();
1369         DOMString name         = arg->getNodeName();
1370         std::vector<NamedNodeMapEntry>::iterator iter;
1371         for (iter = entries.begin() ; iter!=entries.end() ; iter++)
1372             {
1373             if (iter->namespaceURI == namespaceURI && iter->name == name)
1374                 {
1375                 NodePtr node = iter->node;
1376                 iter->node = arg;
1377                 return node;
1378                 }
1379             }
1380         NamedNodeMapEntry entry(namespaceURI, name, arg);
1381         entries.push_back(entry);
1382         return arg;
1383         }
1384
1385     /**
1386      *
1387      */
1388     virtual NodePtr removeNamedItemNS(const DOMString& namespaceURI,
1389                                     const DOMString& localName)
1390                                     throw(DOMException)
1391         {
1392         std::vector<NamedNodeMapEntry>::iterator iter;
1393         for (iter = entries.begin() ; iter!=entries.end() ; iter++)
1394             {
1395             if (iter->namespaceURI == namespaceURI && iter->name == localName)
1396                 {
1397                 NodePtr node = iter->node;
1398                 entries.erase(iter);
1399                 return node;
1400                 }
1401             }
1402         return NULL;
1403         }
1404
1405     //##################
1406     //# Non-API methods
1407     //##################
1408
1409     /**
1410      *
1411      */
1412     NamedNodeMap() {}
1413
1414
1415     /**
1416      *
1417      */
1418     NamedNodeMap(const NamedNodeMap &other)
1419         {
1420         entries = other.entries;
1421         }
1422
1423     /**
1424      *
1425      */
1426     NamedNodeMap &operator=(const NamedNodeMap &other)
1427         {
1428         entries = other.entries;
1429         return *this;
1430         }
1431
1432
1433     /**
1434      *
1435      */
1436     virtual ~NamedNodeMap() {}
1437
1438 protected:
1439
1440     std::vector<NamedNodeMapEntry> entries;
1441
1442 };
1443
1444
1445
1446
1447 /*#########################################################################
1448 ## CharacterData
1449 #########################################################################*/
1450
1451 /**
1452  *
1453  */
1454 class CharacterData : virtual public Node
1455 {
1456 public:
1457
1458     /**
1459      *
1460      */
1461     virtual DOMString getData() throw(DOMException) = 0;
1462
1463     /**
1464      *
1465      */
1466     virtual void setData(const DOMString& val) throw(DOMException) = 0;
1467
1468     /**
1469      *
1470      */
1471     virtual unsigned long getLength() = 0;
1472
1473     /**
1474      *
1475      */
1476     virtual DOMString substringData(unsigned long offset,
1477                             unsigned long count)
1478                             throw(DOMException) = 0;
1479
1480     /**
1481      *
1482      */
1483     virtual void appendData(const DOMString& arg) throw(DOMException) = 0;
1484
1485     /**
1486      *
1487      */
1488     virtual void insertData(unsigned long offset,
1489                     const DOMString& arg)
1490                     throw(DOMException) = 0;
1491
1492     /**
1493      *
1494      */
1495     virtual void deleteData(unsigned long offset,
1496                     unsigned long count)
1497                     throw(DOMException) = 0;
1498
1499     /**
1500      *
1501      */
1502     virtual void  replaceData(unsigned long offset,
1503                       unsigned long count,
1504                       const DOMString& arg)
1505                       throw(DOMException) = 0;
1506
1507
1508     //##################
1509     //# Non-API methods
1510     //##################
1511
1512
1513     /**
1514      *
1515      */
1516     virtual ~CharacterData() {}
1517
1518 };
1519
1520
1521 typedef Ptr<CharacterData> CharacterDataPtr;
1522
1523
1524
1525
1526 /*#########################################################################
1527 ## Attr
1528 #########################################################################*/
1529
1530 /**
1531  *
1532  */
1533 class Attr : virtual public Node
1534 {
1535 public:
1536
1537     /**
1538      *
1539      */
1540     virtual DOMString getName() = 0;
1541
1542     /**
1543      *
1544      */
1545     virtual bool getSpecified() = 0;
1546
1547     /**
1548      *
1549      */
1550     virtual DOMString getValue() = 0;
1551
1552     /**
1553      *
1554      */
1555     virtual void setValue(const DOMString& val) throw(DOMException) = 0;
1556
1557     /**
1558      *
1559      */
1560     virtual ElementPtr getOwnerElement() = 0;
1561
1562
1563     /**
1564      *
1565      */
1566     virtual TypeInfo &getSchemaTypeInfo() = 0;
1567
1568
1569     /**
1570      *
1571      */
1572     virtual bool getIsId() = 0;
1573
1574     //##################
1575     //# Non-API methods
1576     //##################
1577
1578
1579     /**
1580      *
1581      */
1582     virtual ~Attr() {}
1583
1584 };
1585
1586
1587
1588
1589
1590 /*#########################################################################
1591 ## Element
1592 #########################################################################*/
1593
1594 /**
1595  *
1596  */
1597 class Element : virtual public Node
1598 {
1599 public:
1600
1601
1602     /**
1603      *
1604      */
1605     virtual DOMString getTagName() = 0;
1606
1607     /**
1608      *
1609      */
1610     virtual DOMString getAttribute(const DOMString& name) = 0;
1611
1612     /**
1613      *
1614      */
1615     virtual void setAttribute(const DOMString& name,
1616                       const DOMString& value)
1617                       throw(DOMException) = 0;
1618
1619     /**
1620      *
1621      */
1622     virtual void removeAttribute(const DOMString& name)
1623                          throw(DOMException) = 0;
1624
1625     /**
1626      *
1627      */
1628     virtual AttrPtr getAttributeNode(const DOMString& name) = 0;
1629
1630     /**
1631      *
1632      */
1633     virtual AttrPtr setAttributeNode(AttrPtr newAttr)
1634                           throw(DOMException) = 0;
1635
1636     /**
1637      *
1638      */
1639     virtual AttrPtr removeAttributeNode(AttrPtr oldAttr)
1640                              throw(DOMException) = 0;
1641
1642     /**
1643      *
1644      */
1645     virtual NodeList getElementsByTagName(const DOMString& name) = 0;
1646
1647     /**
1648      *
1649      */
1650     virtual DOMString getAttributeNS(const DOMString& namespaceURI,
1651                              const DOMString& localName) = 0;
1652
1653     /**
1654      *
1655      */
1656     virtual void setAttributeNS(const DOMString& namespaceURI,
1657                         const DOMString& qualifiedName,
1658                         const DOMString& value)
1659                         throw(DOMException) = 0;
1660
1661     /**
1662      *
1663      */
1664     virtual void removeAttributeNS(const DOMString& namespaceURI,
1665                            const DOMString& localName)
1666                            throw(DOMException) = 0;
1667
1668     /**
1669      *
1670      */
1671     virtual AttrPtr getAttributeNodeNS(const DOMString& namespaceURI,
1672                             const DOMString& localName) = 0;
1673
1674     /**
1675      *
1676      */
1677     virtual AttrPtr setAttributeNodeNS(AttrPtr newAttr)
1678                             throw(DOMException) = 0;
1679
1680     /**
1681      *
1682      */
1683     virtual NodeList getElementsByTagNameNS(const DOMString& namespaceURI,
1684                                     const DOMString& localName) = 0;
1685
1686     /**
1687      *
1688      */
1689     virtual bool hasAttribute(const DOMString& name) = 0;
1690
1691     /**
1692      *
1693      */
1694     virtual bool hasAttributeNS(const DOMString& namespaceURI,
1695                         const DOMString& localName) = 0;
1696
1697     /**
1698      *
1699      */
1700     virtual TypeInfo &getSchemaTypeInfo() = 0;
1701
1702
1703     /**
1704      *
1705      */
1706     virtual void setIdAttribute(const DOMString &name,
1707                                 bool isId) throw (DOMException) = 0;
1708
1709     /**
1710      *
1711      */
1712     virtual void setIdAttributeNS(const DOMString &namespaceURI,
1713                                   const DOMString &localName,
1714                                   bool isId) throw (DOMException) = 0;
1715
1716     /**
1717      *
1718      */
1719     virtual void setIdAttributeNode(const AttrPtr idAttr,
1720                                     bool isId) throw (DOMException) = 0;
1721
1722     //##################
1723     //# Non-API methods
1724     //##################
1725
1726     /**
1727      *
1728      */
1729     virtual ~Element() {}
1730
1731 };
1732
1733
1734
1735
1736
1737 /*#########################################################################
1738 ## Text
1739 #########################################################################*/
1740
1741 /**
1742  *
1743  */
1744 class Text : virtual public CharacterData
1745 {
1746 public:
1747
1748     /**
1749      *
1750      */
1751     virtual TextPtr splitText(unsigned long offset)
1752                     throw(DOMException) = 0;
1753
1754     /**
1755      *
1756      */
1757     virtual bool getIsElementContentWhitespace()= 0;
1758
1759     /**
1760      *
1761      */
1762     virtual DOMString getWholeText() = 0;
1763
1764
1765     /**
1766      *
1767      */
1768     virtual TextPtr replaceWholeText(const DOMString &content)
1769                                  throw(DOMException) = 0;
1770
1771     //##################
1772     //# Non-API methods
1773     //##################
1774
1775
1776     /**
1777      *
1778      */
1779     virtual ~Text() {}
1780
1781 };
1782
1783
1784
1785 /*#########################################################################
1786 ## Comment
1787 #########################################################################*/
1788
1789 /**
1790  *
1791  */
1792 class Comment : virtual public CharacterData
1793 {
1794 public:
1795
1796     //##################
1797     //# Non-API methods
1798     //##################
1799
1800
1801     /**
1802      *
1803      */
1804     virtual ~Comment() {}
1805
1806
1807 };
1808
1809
1810
1811 /*#########################################################################
1812 ## TypeInfo
1813 #########################################################################*/
1814
1815 /**
1816  *
1817  */
1818 class TypeInfo
1819 {
1820 public:
1821
1822     /**
1823      *
1824      */
1825     virtual DOMString getTypeName()
1826         { return typeName; }
1827
1828     /**
1829      *
1830      */
1831     virtual DOMString getTypeNamespace()
1832         { return typeNameSpace; }
1833
1834     typedef enum
1835         {
1836         DERIVATION_RESTRICTION = 0x00000001,
1837         DERIVATION_EXTENSION   = 0x00000002,
1838         DERIVATION_UNION       = 0x00000004,
1839         DERIVATION_LIST        = 0x00000008
1840         } DerivationMethod;
1841
1842
1843     /**
1844      *
1845      */
1846     virtual bool isDerivedFrom(const DOMString &typeNamespaceArg,
1847                                const DOMString &typeNameArg,
1848                                DerivationMethod derivationMethod)
1849         { return false; }
1850
1851     //##################
1852     //# Non-API methods
1853     //##################
1854
1855
1856     /**
1857      *
1858      */
1859     TypeInfo()
1860             {}
1861
1862     /**
1863      *
1864      */
1865     TypeInfo(const TypeInfo &other)
1866         { assign(other); }
1867
1868     /**
1869      *
1870      */
1871     TypeInfo &operator=(const TypeInfo &other)
1872         { assign(other); return *this; }
1873
1874     /**
1875      *
1876      */
1877     virtual ~TypeInfo() {}
1878
1879 private:
1880
1881     void assign(const TypeInfo &other)
1882         {
1883         typeName      = other.typeName;
1884         typeNameSpace = other.typeNameSpace;
1885         }
1886
1887     DOMString typeName;
1888     DOMString typeNameSpace;
1889 };
1890
1891
1892
1893
1894 /*#########################################################################
1895 ## UserDataHandler
1896 #########################################################################*/
1897
1898 /**
1899  *
1900  */
1901 class UserDataHandler
1902 {
1903 public:
1904
1905     typedef enum
1906         {
1907         NODE_CLONED     = 1,
1908         NODE_IMPORTED   = 2,
1909         NODE_DELETED    = 3,
1910         NODE_RENAMED    = 4,
1911         NODE_ADOPTED    = 5
1912         } OperationType;
1913
1914
1915     /**
1916      *
1917      */
1918     virtual  void handle(unsigned short operation,
1919                          const DOMString &key,
1920                          const DOMUserData *data,
1921                          const NodePtr src,
1922                          const NodePtr dst) =0;
1923
1924     //##################
1925     //# Non-API methods
1926     //##################
1927
1928
1929     /**
1930      *
1931      */
1932     virtual ~UserDataHandler() {}
1933
1934 };
1935
1936
1937 /*#########################################################################
1938 ## DOMError
1939 #########################################################################*/
1940
1941 /**
1942  *
1943  */
1944 class DOMError
1945 {
1946 public:
1947
1948     typedef enum
1949         {
1950         SEVERITY_WARNING     = 1,
1951         SEVERITY_ERROR       = 2,
1952         SEVERITY_FATAL_ERROR = 3
1953         } ErrorSeverity;
1954
1955
1956     /**
1957      *
1958      */
1959     virtual unsigned short getSeverity() =0;
1960
1961     /**
1962      *
1963      */
1964     virtual DOMString getMessage() =0;
1965
1966     /**
1967      *
1968      */
1969     virtual DOMString getType() =0;
1970
1971     /**
1972      *
1973      */
1974     virtual DOMObject *getRelatedException() =0;
1975
1976     /**
1977      *
1978      */
1979     virtual DOMObject *getRelatedData() =0;
1980
1981     /**
1982      *
1983      */
1984     virtual DOMLocator *getLocation() =0;
1985
1986
1987     //##################
1988     //# Non-API methods
1989     //##################
1990
1991
1992     /**
1993      *
1994      */
1995     virtual ~DOMError() {}
1996
1997 };
1998
1999
2000 /*#########################################################################
2001 ## DOMErrorHandler
2002 #########################################################################*/
2003
2004 /**
2005  *
2006  */
2007 class DOMErrorHandler
2008 {
2009 public:
2010     /**
2011      *
2012      */
2013     virtual bool handleError(const DOMError *error) =0;
2014
2015     //##################
2016     //# Non-API methods
2017     //##################
2018
2019
2020     /**
2021      *
2022      */
2023     virtual ~DOMErrorHandler() {}
2024
2025 };
2026
2027
2028
2029 /*#########################################################################
2030 ## DOMLocator
2031 #########################################################################*/
2032
2033 /**
2034  *
2035  */
2036 class DOMLocator
2037 {
2038 public:
2039
2040     /**
2041      *
2042      */
2043     virtual long getLineNumber() =0;
2044
2045     /**
2046      *
2047      */
2048     virtual long getColumnNumber() =0;
2049
2050     /**
2051      *
2052      */
2053     virtual long getByteOffset() =0;
2054
2055     /**
2056      *
2057      */
2058     virtual long getUtf16Offset() =0;
2059
2060
2061     /**
2062      *
2063      */
2064     virtual NodePtr getRelatedNode() =0;
2065
2066
2067     /**
2068      *
2069      */
2070     virtual DOMString getUri() =0;
2071
2072     //##################
2073     //# Non-API methods
2074     //##################
2075
2076     /**
2077      *
2078      */
2079     virtual ~DOMLocator() {}
2080 };
2081
2082
2083 /*#########################################################################
2084 ## DOMConfiguration
2085 #########################################################################*/
2086
2087 /**
2088  *
2089  */
2090 class DOMConfiguration
2091 {
2092 public:
2093
2094     /**
2095      *
2096      */
2097     virtual void setParameter(const DOMString &name,
2098                               const DOMUserData *value)
2099                                                            throw (DOMException) =0;
2100
2101     /**
2102      *
2103      */
2104     virtual DOMUserData *getParameter(const DOMString &name)
2105                                       throw (DOMException) =0;
2106
2107     /**
2108      *
2109      */
2110     virtual bool canSetParameter(const DOMString &name,
2111                                  const DOMUserData *data) =0;
2112
2113     /**
2114      *
2115      */
2116     virtual DOMStringList *getParameterNames() =0;
2117
2118     //##################
2119     //# Non-API methods
2120     //##################
2121
2122
2123     /**
2124      *
2125      */
2126     virtual ~DOMConfiguration() {}
2127
2128 };
2129
2130
2131
2132
2133
2134
2135 /*#########################################################################
2136 ## CDATASection
2137 #########################################################################*/
2138 /**
2139  *
2140  */
2141 class CDATASection : virtual public Text
2142 {
2143 public:
2144
2145     //##################
2146     //# Non-API methods
2147     //##################
2148
2149
2150     /**
2151      *
2152      */
2153     virtual ~CDATASection() {}
2154
2155 };
2156
2157
2158
2159
2160 /*#########################################################################
2161 ## DocumentType
2162 #########################################################################*/
2163
2164 /**
2165  *
2166  */
2167 class DocumentType : virtual public Node
2168 {
2169 public:
2170
2171     /**
2172      *
2173      */
2174     virtual DOMString getName() = 0;
2175
2176     /**
2177      *
2178      */
2179     virtual NamedNodeMap getEntities() = 0;
2180
2181     /**
2182      *
2183      */
2184     virtual NamedNodeMap getNotations() = 0;
2185
2186     /**
2187      *
2188      */
2189     virtual DOMString getPublicId() = 0;
2190
2191     /**
2192      *
2193      */
2194     virtual DOMString getSystemId() = 0;
2195
2196     /**
2197      *
2198      */
2199     virtual DOMString getInternalSubset() = 0;
2200
2201     //##################
2202     //# Non-API methods
2203     //##################
2204
2205     /**
2206      *
2207      */
2208     virtual ~DocumentType() {}
2209
2210 };
2211
2212
2213
2214
2215
2216 /*#########################################################################
2217 ## Notation
2218 #########################################################################*/
2219
2220 /**
2221  *
2222  */
2223 class Notation : virtual public Node
2224 {
2225 public:
2226
2227     /**
2228      *
2229      */
2230     virtual DOMString getPublicId() = 0;
2231
2232     /**
2233      *
2234      */
2235     virtual DOMString getSystemId() = 0;
2236
2237     //##################
2238     //# Non-API methods
2239     //##################
2240
2241
2242     /**
2243      *
2244      */
2245     virtual ~Notation() {}
2246 };
2247
2248
2249
2250
2251
2252
2253 /*#########################################################################
2254 ## Entity
2255 #########################################################################*/
2256
2257 /**
2258  *
2259  */
2260 class Entity : virtual public Node
2261 {
2262 public:
2263
2264     /**
2265      *
2266      */
2267     virtual DOMString getPublicId() = 0;
2268
2269     /**
2270      *
2271      */
2272     virtual DOMString getSystemId() = 0;
2273
2274     /**
2275      *
2276      */
2277     virtual DOMString getNotationName() = 0;
2278
2279     /**
2280      *
2281      */
2282     virtual DOMString getInputEncoding() = 0;
2283
2284     /**
2285      *
2286      */
2287     virtual DOMString getXmlEncoding() = 0;
2288
2289     /**
2290      *
2291      */
2292     virtual DOMString getXmlVersion() = 0;
2293
2294     //##################
2295     //# Non-API methods
2296     //##################
2297
2298
2299     /**
2300      *
2301      */
2302     virtual ~Entity() {}
2303 };
2304
2305
2306
2307
2308
2309 /*#########################################################################
2310 ## EntityReference
2311 #########################################################################*/
2312 /**
2313  *
2314  */
2315 class EntityReference : virtual public Node
2316 {
2317 public:
2318
2319
2320     //##################
2321     //# Non-API methods
2322     //##################
2323
2324     /**
2325      *
2326      */
2327     virtual ~EntityReference() {}
2328 };
2329
2330
2331
2332
2333
2334 /*#########################################################################
2335 ## ProcessingInstruction
2336 #########################################################################*/
2337
2338 /**
2339  *
2340  */
2341 class ProcessingInstruction : virtual public Node
2342 {
2343 public:
2344
2345     /**
2346      *
2347      */
2348     virtual DOMString getTarget() = 0;
2349
2350     /**
2351      *
2352      */
2353     virtual DOMString getData() = 0;
2354
2355     /**
2356      *
2357      */
2358    virtual void setData(const DOMString& val) throw(DOMException) = 0;
2359
2360     //##################
2361     //# Non-API methods
2362     //##################
2363
2364
2365     /**
2366      *
2367      */
2368     virtual ~ProcessingInstruction() {}
2369
2370 };
2371
2372
2373
2374
2375
2376 /*#########################################################################
2377 ## DocumentFragment
2378 #########################################################################*/
2379 /**
2380  *
2381  */
2382 class DocumentFragment : virtual public Node
2383 {
2384 public:
2385
2386     //##################
2387     //# Non-API methods
2388     //##################
2389
2390
2391     /**
2392      *
2393      */
2394     virtual ~DocumentFragment() {}
2395 };
2396
2397
2398
2399
2400
2401
2402 /*#########################################################################
2403 ## Document
2404 #########################################################################*/
2405
2406 /**
2407  *
2408  */
2409 class Document : virtual public Node
2410 {
2411 public:
2412
2413     /**
2414      *
2415      */
2416     virtual DocumentTypePtr getDoctype() = 0;
2417
2418     /**
2419      *
2420      */
2421     virtual DOMImplementation *getImplementation() = 0;
2422
2423     /**
2424      *
2425      */
2426     virtual ElementPtr getDocumentElement() = 0;
2427
2428     /**
2429      *
2430      */
2431     virtual ElementPtr createElement(const DOMString& tagName)
2432                            throw(DOMException) = 0;
2433
2434     /**
2435      *
2436      */
2437     virtual DocumentFragmentPtr createDocumentFragment() = 0;
2438
2439     /**
2440      *
2441      */
2442     virtual TextPtr createTextNode(const DOMString& data) = 0;
2443
2444     /**
2445      *
2446      */
2447     virtual CommentPtr createComment(const DOMString& data) = 0;
2448
2449     /**
2450      *
2451      */
2452     virtual CDATASectionPtr createCDATASection(const DOMString& data)
2453                                      throw(DOMException) = 0;
2454
2455     /**
2456      *
2457      */
2458     virtual ProcessingInstructionPtr
2459                    createProcessingInstruction(const DOMString& target,
2460                                            const DOMString& data)
2461                                            throw(DOMException) = 0;
2462
2463     /**
2464      *
2465      */
2466     virtual AttrPtr createAttribute(const DOMString& name)
2467                           throw(DOMException) = 0;
2468
2469     /**
2470      *
2471      */
2472     virtual EntityReferencePtr createEntityReference(const DOMString& name)
2473                                            throw(DOMException) = 0;
2474
2475     /**
2476      *
2477      */
2478     virtual NodeList getElementsByTagName(const DOMString& tagname) = 0;
2479
2480
2481     /**
2482      *
2483      */
2484     virtual NodePtr importNode(const NodePtr importedNode,
2485                      bool deep)
2486                      throw(DOMException) = 0;
2487
2488     /**
2489      *
2490      */
2491     virtual ElementPtr createElementNS(const DOMString& namespaceURI,
2492                              const DOMString& qualifiedName)
2493                              throw(DOMException) = 0;
2494
2495     /**
2496      *
2497      */
2498     virtual AttrPtr createAttributeNS(const DOMString& namespaceURI,
2499                             const DOMString& qualifiedName)
2500                             throw(DOMException) = 0;
2501
2502     /**
2503      *
2504      */
2505     virtual NodeList getElementsByTagNameNS(const DOMString& namespaceURI,
2506                                      const DOMString& localName) = 0;
2507
2508     /**
2509      *
2510      */
2511     virtual ElementPtr getElementById(const DOMString& elementId) = 0;
2512
2513
2514     /**
2515      *
2516      */
2517     virtual DOMString getInputEncoding() = 0;
2518
2519
2520     /**
2521      *
2522      */
2523     virtual DOMString getXmlEncoding() = 0;
2524
2525     /**
2526      *
2527      */
2528     virtual bool getXmlStandalone() = 0;
2529
2530     /**
2531      *
2532      */
2533     virtual void setXmlStandalone(bool val) throw (DOMException) = 0;
2534
2535     /**
2536      *
2537      */
2538     virtual DOMString getXmlVersion() = 0;
2539
2540     /**
2541      *
2542      */
2543     virtual void setXmlVersion(const DOMString &version)
2544                                    throw (DOMException) = 0;
2545
2546     /**
2547      *
2548      */
2549     virtual bool getStrictErrorChecking() = 0;
2550
2551     /**
2552      *
2553      */
2554     virtual void setStrictErrorChecking(bool val) = 0;
2555
2556
2557     /**
2558      *
2559      */
2560     virtual DOMString getDocumentURI() = 0;
2561
2562     /**
2563      *
2564      */
2565     virtual void setDocumentURI(const DOMString &uri) = 0;
2566
2567     /**
2568      *
2569      */
2570     virtual NodePtr adoptNode(const NodePtr source) throw (DOMException) = 0;
2571
2572     /**
2573      *
2574      */
2575     virtual DOMConfiguration *getDomConfig() = 0;
2576
2577     /**
2578      *
2579      */
2580     virtual void normalizeDocument() = 0;
2581
2582     /**
2583      *
2584      */
2585     virtual NodePtr renameNode(const NodePtr n,
2586                                const DOMString &namespaceURI,
2587                                const DOMString &qualifiedName)
2588                                throw (DOMException) = 0;
2589
2590
2591     //##################
2592     //# Non-API methods
2593     //##################
2594
2595     /**
2596      *
2597      */
2598     virtual ~Document() {}
2599
2600 };
2601
2602
2603
2604
2605
2606
2607
2608
2609 }  //namespace dom
2610 }  //namespace w3c
2611 }  //namespace org
2612
2613
2614 #endif // __DOM_H__
2615
2616
2617 /*#########################################################################
2618 ## E N D    O F    F I L E
2619 #########################################################################*/
2620
2621
2622
2623