dom.h revision 36d9047104b5881ca587a71ade77b1f21d083bc4
#ifndef SEEN_DOM_H
#define SEEN_DOM_H
/**
* @file
* Phoebe DOM Implementation.
*
* This is a C++ approximation of the W3C DOM model, which follows
* fairly closely the specifications in the various .idl files, copies of
* which are provided for reference. Most important is this one:
*
* http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/idl-definitions.html
*
* More thorough explanations of the various classes and their algorithms
* can be found there.
*
*/
/*
* Authors:
* Bob Jamison
*
* Copyright (C) 2006-2008 Bob Jamison
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
* =======================================================================
* NOTES:
*
* Notice that many of the classes defined here are pure virtual. In other
* words, they are purely unimplemented interfaces. For the implementations
* of them, look in domimpl.h and domimpl.cpp.
*
* Also, note that there is a domptr.cpp file that has a couple of necessary
* functions which cannot be in a .h file.
*
* Some of the comments below are quoted from the W3C spec:
* http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html
*
*/
#include <vector>
#include "domptr.h"
/**
* What type of string do we want? Pick one of the following
* Then below, select one of the corresponding typedefs.
*/
#ifdef DOM_STANDALONE
#include <string>
#else
#include <glibmm.h>
#endif
//# Unfortunate hack for a name collision
#ifdef SEVERITY_ERROR
#undef SEVERITY_ERROR
#endif
#define XMLNSNAME "http://www.w3.org/2000/xmlns/"
namespace org
{
namespace w3c
{
namespace dom
{
/**
* This is the org::w3c::dom::DOMString definition.
* Which type do we want?
*/
#ifdef DOM_STANDALONE
typedef std::string DOMString;
typedef unsigned short XMLCh;
#else
typedef Glib::ustring DOMString;
typedef gunichar XMLCh;
#endif
/**
* At least 64 bit time stamp value.
*/
typedef unsigned long long DOMTimeStamp;
/**
* This is used for storing refs to user-supplied data.
*/
typedef void DOMUserData;
/**
* This is used for opaque references to arbitrary objects from
* the DOM tree.
*/
typedef void DOMObject;
/**
* Forward references. These are needed because of extensive
* inter-referencing within the DOM tree.
*/
class NodeList;
class NamedNodeMap;
class DOMException;
class DOMStringList;
class NameList;
class DOMImplementationList;
class DOMImplementationSource;
class DOMImplementation;
class TypeInfo;
class UserDataHandler;
class DOMError;
class DOMErrorHandler;
class DOMLocator;
class DOMConfiguration;
/**
* Smart pointer definitions. Most methods that return references to
* Nodes of various types, will return one of these smart pointers instead,
* to allow refcounting and GC.
*/
class Node;
typedef Ptr<Node> NodePtr;
class CharacterData;
typedef Ptr<CharacterData> CharacterDataPtr;
class Attr;
typedef Ptr<Attr> AttrPtr;
class Element;
typedef Ptr<Element> ElementPtr;
class Text;
typedef Ptr<Text> TextPtr;
class Comment;
typedef Ptr<Comment> CommentPtr;
class DocumentType;
typedef Ptr<DocumentType> DocumentTypePtr;
class CDATASection;
typedef Ptr<CDATASection> CDATASectionPtr;
class Notation;
typedef Ptr<Notation> NotationPtr;
class Entity;
typedef Ptr<Entity> EntityPtr;
class EntityReference;
typedef Ptr<EntityReference> EntityReferencePtr;
class ProcessingInstruction;
typedef Ptr<ProcessingInstruction> ProcessingInstructionPtr;
class DocumentFragment;
typedef Ptr<DocumentFragment> DocumentFragmentPtr;
class Document;
typedef Ptr<Document> DocumentPtr;
/**
* NOTE: We were originally intending to split ALL specifications into
* interface and implementation. After consideration, though, it behooves
* us to simplify things by implementing the base exception and
* container classes directly:
*
* DOMException
* DOMStringList
* NameList
* DOMImplementationList
* DOMImplementationSource
* DOMImplementation
* NodeList
* NamedNodeMap
*/
/*#########################################################################
## DOMException
#########################################################################*/
/**
* An Exception class. Not an interface, since this is something that
* all implementations must support.
*/
class DOMException
{
public:
/**
* ExceptionCode
*/
typedef enum
{
INDEX_SIZE_ERR = 1,
DOMSTRING_SIZE_ERR = 2,
HIERARCHY_REQUEST_ERR = 3,
WRONG_DOCUMENT_ERR = 4,
INVALID_CHARACTER_ERR = 5,
NO_DATA_ALLOWED_ERR = 6,
NO_MODIFICATION_ALLOWED_ERR = 7,
NOT_FOUND_ERR = 8,
NOT_SUPPORTED_ERR = 9,
INUSE_ATTRIBUTE_ERR = 10,
INVALID_STATE_ERR = 11,
SYNTAX_ERR = 12,
INVALID_MODIFICATION_ERR = 13,
NAMESPACE_ERR = 14,
INVALID_ACCESS_ERR = 15,
VALIDATION_ERR = 16,
TYPE_MISMATCH_ERR = 17
} ExceptionCode;
DOMException(const DOMString &reasonMsg)
{ msg = reasonMsg; }
DOMException(short theCode)
{
code = theCode;
}
virtual ~DOMException() throw()
{}
/**
* What type of exception? One of the ExceptionCodes above.
*/
unsigned short code;
/**
* Some text describing the context that generated this exception.
*/
DOMString msg;
/**
* Get a string, translated from the code.
* Like std::exception. Not in spec.
*/
const char *what()
{ return (const char *)msg.c_str(); }
};
/*#########################################################################
## DOMStringList
#########################################################################*/
/**
* This holds a list of DOMStrings. This is likely the response to a query,
* or the value of an attribute.
*/
class DOMStringList
{
public:
/**
* Get the nth string of the list
*/
virtual DOMString item(unsigned long index)
{
if (index>=strings.size())
return "";
return strings[index];
}
/**
* How many strings in this list?
*/
virtual unsigned long getLength()
{
return (unsigned long) strings.size();
}
/**
* Is the argument string present in this list? Lexically, not identically.
*/
virtual bool contains(const DOMString &str)
{
for (unsigned int i=0; i<strings.size() ; i++)
{
if (strings[i] == str)
return true;
}
return false;
}
//##################
//# Non-API methods
//##################
/**
*
*/
DOMStringList() {}
/**
*
*/
DOMStringList(const DOMStringList &other)
{
strings = other.strings;
}
/**
*
*/
DOMStringList &operator=(const DOMStringList &other)
{
strings = other.strings;
return *this;
}
/**
*
*/
virtual ~DOMStringList() {}
protected:
/**
*
*/
virtual void add(const DOMString &str)
{
strings.push_back(str);
}
std::vector<DOMString>strings;
};
/*#########################################################################
## NameList
#########################################################################*/
/**
* Constains a list of namespaced names.
*/
class NameList
{
private:
class NamePair
{
public:
NamePair(const DOMString &theNamespaceURI, const DOMString &theName)
{
namespaceURI = theNamespaceURI;
name = theName;
}
NamePair(const NamePair &other)
{
namespaceURI = other.namespaceURI;
name = other.name;
}
NamePair &operator=(const NamePair &other)
{
namespaceURI = other.namespaceURI;
name = other.name;
return *this;
}
virtual ~NamePair() {}
DOMString namespaceURI;
DOMString name;
};
public:
/**
* Returns a name at the given index. If out of range, return -1.
*/
virtual DOMString getName(unsigned long index)
{
if (index>=namePairs.size())
return "";
return namePairs[index].name;
}
/**
* Returns a namespace at the given index. If out of range, return -1.
*/
virtual DOMString getNamespaceURI(unsigned long index)
{
if (index>=namePairs.size())
return "";
return namePairs[index].namespaceURI;
}
/**
* Return the number of entries in this list.
*/
virtual unsigned long getLength()
{
return (unsigned long)namePairs.size();
}
/**
* Return whether the name argument is present in the list.
* This is done lexically, not identically.
*/
virtual bool contains(const DOMString &name)
{
for (unsigned int i=0; i<namePairs.size() ; i++)
{
if (namePairs[i].name == name )
return true;
}
return false;
}
/**
* Return whether the namespaced name argument is present in the list.
* This is done lexically, not identically.
*/
virtual bool containsNS(const DOMString &namespaceURI, const DOMString &name)
{
for (unsigned int i=0; i<namePairs.size() ; i++)
{
if (namePairs[i].namespaceURI == namespaceURI ||
namePairs[i].name == name )
return true;
}
return false;
}
//##################
//# Non-API methods
//##################
/**
*
*/
NameList() {}
/**
*
*/
NameList(const NameList &other)
{
namePairs = other.namePairs;
}
/**
*
*/
NameList &operator=(const NameList &other)
{
namePairs = other.namePairs;
return *this;
}
/**
*
*/
virtual ~NameList() {}
protected:
std::vector<NamePair> namePairs;
};
/*#########################################################################
## DOMImplementationList
#########################################################################*/
/**
* Contains a list of DOMImplementations, with accessors.
*/
class DOMImplementationList
{
public:
/**
* Return a DOMImplementation at the given index. If
* out of range, return NULL.
*/
virtual DOMImplementation *item(unsigned long index)
{
if (index >implementations.size())
return NULL;
return implementations[index];
}
/**
* Return the number of DOMImplementations in this list.
*/
virtual unsigned long getLength()
{
return (unsigned long) implementations.size();
}
//##################
//# Non-API methods
//##################
/**
*
*/
DOMImplementationList() {}
/**
*
*/
DOMImplementationList(const DOMImplementationList &other)
{
implementations = other.implementations;
}
/**
*
*/
DOMImplementationList &operator=(const DOMImplementationList &other)
{
implementations = other.implementations;
return *this;
}
/**
*
*/
virtual ~DOMImplementationList() {}
protected:
std::vector<DOMImplementation *>implementations;
};
/*#########################################################################
## DOMImplementationSource
#########################################################################*/
/**
* This is usually the first item to be called when creating a Document.
* You will either find one DOMImplementation with a given set of features,
* or return a list that match. Using "" will get any implementation
* available.
*/
class DOMImplementationSource
{
public:
/**
* Return the first DOMImplementation with the given set of features.
* Use "" to fetch any implementation.
*/
virtual DOMImplementation *getDOMImplementation(const DOMString &features) = 0;
/**
* Return a list of DOMImplementations with the given set of features.
* Use "" to fetch any implementation.
*/
virtual DOMImplementationList getDOMImplementationList(const DOMString &features) = 0;
//##################
//# Non-API methods
//##################
/**
*
*/
virtual ~DOMImplementationSource() {}
};
/*#########################################################################
## DOMImplementation
#########################################################################*/
/**
* This is the class that actually creates a Document.
*/
class DOMImplementation
{
public:
/**
* Determine if this implementation has the given feature and version.
*/
virtual bool hasFeature(const DOMString& feature, const DOMString& version) = 0;
/**
* Create a document type to be used in creating documents.
*/
virtual DocumentTypePtr createDocumentType(
const DOMString& qualifiedName,
const DOMString& publicId,
const DOMString& systemId)
throw(DOMException) = 0;
/**
* Create a DOM document.
*/
virtual DocumentPtr createDocument(const DOMString& namespaceURI,
const DOMString& qualifiedName,
DocumentTypePtr doctype)
throw(DOMException) = 0;
/**
* Return the thing which is the feature of this implementation. Since
* this is a "one size fits all" call, you will need to typecast the
* result to the expected type.
*/
virtual DOMObject *getFeature(const DOMString& feature,
const DOMString& version) = 0;
//##################
//# Non-API methods
//##################
/**
*
*/
virtual ~DOMImplementation() {}
};
/*#########################################################################
## Node
#########################################################################*/
/**
* The basic Node class, which is the root of most other
* classes in DOM. Thus it is by far the most important, and the one
* whose implementation we must perform correctly.
*/
class Node
{
public:
/**
* Which of the DOM Core node types is this node?
*/
typedef enum
{
ELEMENT_NODE = 1,
ATTRIBUTE_NODE = 2,
TEXT_NODE = 3,
CDATA_SECTION_NODE = 4,
ENTITY_REFERENCE_NODE = 5,
ENTITY_NODE = 6,
PROCESSING_INSTRUCTION_NODE = 7,
COMMENT_NODE = 8,
DOCUMENT_NODE = 9,
DOCUMENT_TYPE_NODE = 10,
DOCUMENT_FRAGMENT_NODE = 11,
NOTATION_NODE = 12
} NodeType;
/**
* Return the name of this node.
*/
virtual DOMString getNodeName() = 0;
/**
* Return the value of this node. The interpretation of the
* value is type-specific.
*/
virtual DOMString getNodeValue() throw (DOMException) = 0;
/**
* Set the value of this node. The interpretation of the
* value is type-specific.
*/
virtual void setNodeValue(const DOMString& val) throw (DOMException) = 0;
/**
* Return the type of this Node. One of the NodeType values above.
*/
virtual unsigned short getNodeType() = 0;
/**
* Return the parent which references this node as a child in the DOM
* tree. Return NULL if there is none.
*/
virtual NodePtr getParentNode() = 0;
/**
* Return a list of the children of this Node.
* NOTE: the spec expects this to be a "live" list that always
* reflects an accurate list of what the Node current possesses, not
* a snapshot. How do we do this?
*/
virtual NodeList getChildNodes() = 0;
/**
* Return the first sibling of the chidren of this node. Return
* null if there is none.
*/
virtual NodePtr getFirstChild() = 0;
/**
* Return the last sibling of the children of this node. Return
* null if there is none.
*/
virtual NodePtr getLastChild() = 0;
/**
* Return the node that is previous to this one in the parent's
* list of children. Return null if there is none.
*/
virtual NodePtr getPreviousSibling() = 0;
/**
* Return the node that is after this one in the parent's list
* of children. Return null if there is none.
*/
virtual NodePtr getNextSibling() = 0;
/**
* Get the list of all attributes of this node.
*/
virtual NamedNodeMap &getAttributes() = 0;
/**
* Return the document that created or inherited this node.
*/
virtual DocumentPtr getOwnerDocument() = 0;
/**
* Insert a node as a new child. Place it before the referenced child.
* Place it at the end if the referenced child does not exist.
*/
virtual NodePtr insertBefore(const NodePtr newChild,
const NodePtr refChild)
throw(DOMException) = 0;
/**
* Insert a node as a new child. Replace the referenced child with it.
* Place it at the end if the referenced child does not exist.
*/
virtual NodePtr replaceChild(const NodePtr newChild,
const NodePtr oldChild)
throw(DOMException) = 0;
/**
* Remove a node from the list of children. Do nothing if the
* node is not a member of the child list.
*/
virtual NodePtr removeChild(const NodePtr oldChild)
throw(DOMException) = 0;
/**
* Add the node to the end of this node's child list.
*/
virtual NodePtr appendChild(const NodePtr newChild)
throw(DOMException) = 0;
/**
* Return true if this node has one or more children, else return false.
*/
virtual bool hasChildNodes() = 0;
/**
* Return a new node which has the name, type, value, attributes, and
* child list as this one.
* If 'deep' is true, continue cloning recursively with this node's children,
* so that the child list also contains clones of their respective nodes.
*/
virtual NodePtr cloneNode(bool deep) = 0;
/**
* Adjust this node and its children to have its namespaces and
* prefixes in "canonical" order.
*/
virtual void normalize() = 0;
/**
* Return true if the named feature is supported by this node,
* else false.
*/
virtual bool isSupported(const DOMString& feature,
const DOMString& version) = 0;
/**
* Return the namespace of this node. This would be whether the
* namespace were declared explicitly on this node, it has a namespace
* prefix, or it is inherits the namespace from an ancestor node.
*/
virtual DOMString getNamespaceURI() = 0;
/**
* Return the namespace prefix of this node, if any. For example, if
* the tag were <svg:image> then the prefix would be "svg"
*/
virtual DOMString getPrefix() = 0;
/**
* Sets the namespace prefix of this node to the given value. This
* does not change the namespaceURI value.
*/
virtual void setPrefix(const DOMString& val) throw(DOMException) = 0;
/**
* Return the local name of this node. This is merely the name without
* any namespace or prefix.
*/
virtual DOMString getLocalName() = 0;
/**
* Return true if this node has one or more attributes, else false.
*/
virtual bool hasAttributes() = 0;
/**
* Return the base URI of this node. This is basically the "location" of this
* node, and is used in resolving the relative locations of other URIs.
*/
virtual DOMString getBaseURI() = 0;
/**
* DocumentPosition.
* This is used to describe the position of one node relative
* to another in a document
*/
typedef enum
{
DOCUMENT_POSITION_DISCONNECTED = 0x01,
DOCUMENT_POSITION_PRECEDING = 0x02,
DOCUMENT_POSITION_FOLLOWING = 0x04,
DOCUMENT_POSITION_CONTAINS = 0x08,
DOCUMENT_POSITION_CONTAINED_BY = 0x10,
DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 0x20
} DocumentPosition;
/**
* Get the position of this node relative to the node argument.
*/
virtual unsigned short compareDocumentPosition(
const NodePtr other) = 0;
/**
* This is a DOM L3 method. Return the text value of this node and its
* children. This is done by concatenating all of the TEXT_NODE and
* CDATA_SECTION nodes of this node and its children, in order, together.
* Very handy.
*/
virtual DOMString getTextContent() throw(DOMException) = 0;
/**
* This is a DOM L3 method. Remember, this is a destructive call. This
* will replace all of the child nodes of this node with a single TEXT_NODE
* with the given text value.
*/
virtual void setTextContent(const DOMString &val) throw(DOMException) = 0;
/**
* This will search the tree from this node up, for a prefix that
* has been assigned to the namespace argument. Return "" if not found.
*/
virtual DOMString lookupPrefix(const DOMString &namespaceURI) =0;
/**
* Return true if this node is in the namespace of the argument, without
* requiring an explicit namespace declaration or a suffix.
*/
virtual bool isDefaultNamespace(const DOMString &namespaceURI) =0;
/**
* This will search the tree from this node up, for a namespace that
* has been assigned the suffix in the argument. Return "" if not found.
*/
virtual DOMString lookupNamespaceURI(const DOMString &prefix) =0;
/**
* Return true if the argument node is equal to this one. Use W3C rules
* for equality.
*/
virtual bool isEqualNode(const NodePtr node) =0;
/**
* Return an opaque reference to the named feature. Return null if
* not supported. Using other than "" for the version will look for
* a feature with the given version.
*/
virtual DOMObject *getFeature(const DOMString &feature,
const DOMString &version) =0;
/**
* Store a user data reference in this node, using the given key.
* A handler is an optional function object that will be called during
* future settings of this value. See UserDataHandler for more info.
*/
virtual DOMUserData *setUserData(const DOMString &key,
const DOMUserData *data,
const UserDataHandler *handler) =0;
/**
* Return a reference to the named user data object. Return null
* if it does not exist.
*/
virtual DOMUserData *getUserData(const DOMString &key) =0;
//##################
//# Non-API methods
//##################
/**
*
*/
Node() : _refCnt(0)
{}
/**
*
*/
virtual ~Node() {}
protected:
friend void incrementRefCount(Node *p);
friend void decrementRefCount(Node *p);
/**
* For the Ptr smart pointer
*/
int _refCnt;
};
/*#########################################################################
## NodeList
#########################################################################*/
/**
* Contains a list of Nodes. This is the standard API container for Nodes,
* and is used in lieu of other lists, arrays, etc, in order to provide
* a consistent API and algorithm.
*/
class NodeList
{
public:
/**
* Retrieve the Node at the given index. Return NULL
* if out of range.
*/
virtual NodePtr item(unsigned long index)
{
if (index>=nodes.size())
return NULL;
return nodes[index];
}
/**
* Get the number of nodes in this list
*/
virtual unsigned long getLength()
{
return (unsigned long) nodes.size();
}
//##################
//# Non-API methods
//##################
/**
*
*/
NodeList() {}
/**
*
*/
NodeList(const NodeList &other)
{
nodes = other.nodes;
}
/**
*
*/
NodeList &operator=(const NodeList &other)
{
nodes = other.nodes;
return *this;
}
/**
*
*/
virtual ~NodeList() {}
/**
*
*/
virtual void clear()
{
nodes.clear();
}
protected:
friend class NodeImpl;
friend class ElementImpl;
/*
*
*/
virtual void add(const NodePtr node)
{
nodes.push_back(node);
}
protected:
std::vector<NodePtr> nodes;
};
/*#########################################################################
## NamedNodeMap
#########################################################################*/
/**
* Contains a mapping from name->NodePtr. Used for various purposes. For
* example, a list of Attributes is a NamedNodeMap.
*/
class NamedNodeMap
{
private:
/**
* table entry. Not an API item
*/
class NamedNodeMapEntry
{
public:
NamedNodeMapEntry(const DOMString &theNamespaceURI,
const DOMString &theName,
const NodePtr theNode)
{
namespaceURI = theNamespaceURI;
name = theName;
node = theNode;
}
NamedNodeMapEntry(const NamedNodeMapEntry &other)
{
assign(other);
}
NamedNodeMapEntry &operator=(const NamedNodeMapEntry &other)
{
assign(other);
return *this;
}
virtual ~NamedNodeMapEntry()
{
}
void assign(const NamedNodeMapEntry &other)
{
namespaceURI = other.namespaceURI;
name = other.name;
node = other.node;
}
DOMString namespaceURI;
DOMString name;
NodePtr node;
};
public:
/**
* Return the named node. Return nullptr if not found.
*/
virtual NodePtr getNamedItem(const DOMString& name)
{
std::vector<NamedNodeMapEntry>::iterator iter;
for (iter = entries.begin() ; iter!=entries.end() ; ++iter)
{
if (iter->name == name)
{
NodePtr node = iter->node;
return node;
}
}
return NULL;
}
/**
* Adds a node using its nodeName attribute. If a node with that name is already
* present in this map, it is replaced by the new one. Replacing a node by itself
* has no effect.
*/
virtual NodePtr setNamedItem(NodePtr arg) throw(DOMException)
{
if (!arg)
return NULL;
DOMString namespaceURI = arg->getNamespaceURI();
DOMString name = arg->getNodeName();
std::vector<NamedNodeMapEntry>::iterator iter;
for (iter = entries.begin() ; iter!=entries.end() ; ++iter)
{
if (iter->name == name)
{
NodePtr node = iter->node;
iter->node = arg;
return node;
}
}
NamedNodeMapEntry entry(namespaceURI, name, arg);
entries.push_back(entry);
return arg;
}
/**
* Removes a node specified by name.
*/
virtual NodePtr removeNamedItem(const DOMString& name) throw(DOMException)
{
std::vector<NamedNodeMapEntry>::iterator iter;
for (iter = entries.begin() ; iter!=entries.end() ; ++iter)
{
if (iter->name == name)
{
NodePtr node = iter->node;
entries.erase(iter);
return node;
}
}
return NULL;
}
/**
* Retrieves an item at the given index. If out of bounds, return NULL
*/
virtual NodePtr item(unsigned long index)
{
if (index>=entries.size())
return NULL;
return entries[index].node;
}
/**
* Return the number of items in this map
*/
virtual unsigned long getLength()
{
return (unsigned long)entries.size();
}
/**
* Retrieves a node specified by local name and namespace URI.
*/
virtual NodePtr getNamedItemNS(const DOMString& namespaceURI,
const DOMString& localName)
{
std::vector<NamedNodeMapEntry>::iterator iter;
for (iter = entries.begin() ; iter!=entries.end() ; ++iter)
{
if (iter->namespaceURI == namespaceURI && iter->name == localName)
{
NodePtr node = iter->node;
return node;
}
}
return NULL;
}
/**
* Adds a node using its namespaceURI and localName. If a node with that
* namespace URI and that local name is already present in this map, it is
* replaced by the new one. Replacing a node by itself has no effect.
*/
virtual NodePtr setNamedItemNS(NodePtr arg) throw(DOMException)
{
if (!arg)
return NULL;
DOMString namespaceURI = arg->getNamespaceURI();
DOMString name = arg->getNodeName();
std::vector<NamedNodeMapEntry>::iterator iter;
for (iter = entries.begin() ; iter!=entries.end() ; ++iter)
{
if (iter->namespaceURI == namespaceURI && iter->name == name)
{
NodePtr node = iter->node;
iter->node = arg;
return node;
}
}
NamedNodeMapEntry entry(namespaceURI, name, arg);
entries.push_back(entry);
return arg;
}
/**
* Removes a node specified by local name and namespace URI.
*/
virtual NodePtr removeNamedItemNS(const DOMString& namespaceURI,
const DOMString& localName)
throw(DOMException)
{
std::vector<NamedNodeMapEntry>::iterator iter;
for (iter = entries.begin() ; iter!=entries.end() ; ++iter)
{
if (iter->namespaceURI == namespaceURI && iter->name == localName)
{
NodePtr node = iter->node;
entries.erase(iter);
return node;
}
}
return NULL;
}
//##################
//# Non-API methods
//##################
/**
*
*/
NamedNodeMap() {}
/**
*
*/
NamedNodeMap(const NamedNodeMap &other)
{
entries = other.entries;
}
/**
*
*/
NamedNodeMap &operator=(const NamedNodeMap &other)
{
entries = other.entries;
return *this;
}
/**
*
*/
virtual ~NamedNodeMap() {}
protected:
std::vector<NamedNodeMapEntry> entries;
};
/*#########################################################################
## CharacterData
#########################################################################*/
/**
* This is the base class for other text-oriented Nodes, such as TEXT_NODE
* or CDATA_SECTION_NODE. No DOM objects correspond directly to CharacterData.
*/
class CharacterData : virtual public Node
{
public:
/**
* This is an alias for getNodeValue()
*/
virtual DOMString getData() throw(DOMException) = 0;
/**
* This is an alias for setNodeValue()
*/
virtual void setData(const DOMString& val) throw(DOMException) = 0;
/**
* Return the number of characters contained in this node's data
*/
virtual unsigned long getLength() = 0;
/**
* Return a substring of this node's data, starting at offset, and
* continuing for 'count' characters. Throw an exception if this goes
* out of range.
*/
virtual DOMString substringData(unsigned long offset,
unsigned long count)
throw(DOMException) = 0;
/**
* Append the argument string to the end of the node's current data.
*/
virtual void appendData(const DOMString& arg) throw(DOMException) = 0;
/**
* Insert the argument string at the offset position into the node's
* current data. If the position is out of range, throw an Exception.
*/
virtual void insertData(unsigned long offset,
const DOMString& arg)
throw(DOMException) = 0;
/**
* Delete 'count' characters from the node's data starting from the
* offset position. If this goes out of range, throw an Exception.
*/
virtual void deleteData(unsigned long offset,
unsigned long count)
throw(DOMException) = 0;
/**
* Replace the 'count' characters at the offset position with the given
* argument string. If this goes out of range, throw an Exception.
*/
virtual void replaceData(unsigned long offset,
unsigned long count,
const DOMString& arg)
throw(DOMException) = 0;
//##################
//# Non-API methods
//##################
/**
*
*/
virtual ~CharacterData() {}
};
/*#########################################################################
## Attr
#########################################################################*/
/**
* The Attr interface represents an attribute in an Element object.
* Typically the allowable values for the attribute are defined in a
* schema associated with the document.
* Since Attrs are not considered to be part of the DOM tree, parent,
* previousSibling, and nextSibling are null.
*/
class Attr : virtual public Node
{
public:
/**
* Returns the name of this attribute. If Node.localName is different
* from null, this attribute is a qualified name.
*/
virtual DOMString getName() = 0;
/**
* True if this attribute was explicitly given a value in the instance document,
* false otherwise. If the application changed the value of this attribute node
* (even if it ends up having the same value as the default value) then it is set
* to true. The implementation may handle attributes with default values from
* other schemas similarly but applications should use
* Document.normalizeDocument() to guarantee this information is up-to-date.
*/
virtual bool getSpecified() = 0;
/**
* Returns the value of the attribute
*/
virtual DOMString getValue() = 0;
/**
* Sets the value of the attribute
*/
virtual void setValue(const DOMString& val) throw(DOMException) = 0;
/**
* Return the Element that possesses this attribute
*/
virtual ElementPtr getOwnerElement() = 0;
/**
* The type information associated with this attribute.
*/
virtual TypeInfo &getSchemaTypeInfo() = 0;
/**
* Returns whether this attribute is known to be of type ID (i.e. to contain an
* identifier for its owner element) or not. When it is and its value is unique,
* the ownerElement of this attribute can be retrieved using the method
* Document.getElementById.
*/
virtual bool getIsId() = 0;
//##################
//# Non-API methods
//##################
/**
*
*/
virtual ~Attr() {}
};
/*#########################################################################
## Element
#########################################################################*/
/**
* The Element interface represents an element in an XML document.
* Elements may have attributes associated with them; since the Element interface
* inherits from Node, the generic Node interface attribute attributes may be
* used to retrieve the set of all attributes for an element. There are methods
* on the Element interface to retrieve either an Attr object by name or an
* attribute value by name. In XML, where an attribute value may contain entity
* references, an Attr object should be retrieved to examine the possibly fairly
* complex sub-tree representing the attribute value. On the other hand, in HTML,
* where all attributes have simple string values, methods to directly access an
* attribute value can safely be used as a convenience.
*/
class Element : virtual public Node
{
public:
/**
* The name of the element. If Node.localName is different from null,
* this attribute is a qualified name.
*/
virtual DOMString getTagName() = 0;
/**
* Retrieves an attribute value by name.
*/
virtual DOMString getAttribute(const DOMString& name) = 0;
/**
* Adds a new attribute. If an attribute with that name is already present in the
* element, its value is changed to be that of the value parameter. This value is
* a simple string; it is not parsed as it is being set. So any markup (such as
* syntax to be recognized as an entity reference) is treated as literal text,
* and needs to be appropriately escaped by the implementation when it is written
* out. In order to assign an attribute value that contains entity references,
* the user must create an Attr node plus any Text and EntityReference nodes,
* build the appropriate subtree, and use setAttributeNode to assign it as the
* value of an attribute.
*/
virtual void setAttribute(const DOMString& name,
const DOMString& value)
throw(DOMException) = 0;
/**
* Removes an attribute by name. If no attribute with this name is found,
* this method has no effect.
*/
virtual void removeAttribute(const DOMString& name)
throw(DOMException) = 0;
/**
* Retrieves an attribute node by name.
*/
virtual AttrPtr getAttributeNode(const DOMString& name) = 0;
/**
* Adds a new attribute node. If an attribute with that name (nodeName)
* is already present in the element, it is replaced by the new one.
* Replacing an attribute node by itself has no effect.
*/
virtual AttrPtr setAttributeNode(AttrPtr newAttr)
throw(DOMException) = 0;
/**
* Removes the specified attribute node.
*/
virtual AttrPtr removeAttributeNode(AttrPtr oldAttr)
throw(DOMException) = 0;
/**
* Returns a NodeList of all descendant Elements with a given tag name,
* in document order.
*/
virtual NodeList getElementsByTagName(const DOMString& name) = 0;
/**
* Retrieves an attribute value by local name and namespace URI.
* Per [XML Namespaces], applications must use the value null as the
* namespaceURI parameter for methods if they wish to have no namespace.
*/
virtual DOMString getAttributeNS(const DOMString& namespaceURI,
const DOMString& localName) = 0;
/**
* Adds a new attribute. If an attribute with the same local name and namespace
* URI is already present on the element, its prefix is changed to be the prefix
* part of the qualifiedName, and its value is changed to be the value parameter.
* This value is a simple string; it is not parsed as it is being set. So any
* markup (such as syntax to be recognized as an entity reference) is treated as
* literal text, and needs to be appropriately escaped by the implementation when
* it is written out. In order to assign an attribute value that contains entity
* references, the user must create an Attr node plus any Text and
* EntityReference nodes, build the appropriate subtree, and use
* setAttributeNodeNS or setAttributeNode to assign it as the value of an
* attribute.
*/
virtual void setAttributeNS(const DOMString& namespaceURI,
const DOMString& qualifiedName,
const DOMString& value)
throw(DOMException) = 0;
/**
* Removes an attribute by local name and namespace URI.
*/
virtual void removeAttributeNS(const DOMString& namespaceURI,
const DOMString& localName)
throw(DOMException) = 0;
/**
* Retrieves an Attr node by local name and namespace URI.
*/
virtual AttrPtr getAttributeNodeNS(const DOMString& namespaceURI,
const DOMString& localName) = 0;
/**
* Adds a new attribute. If an attribute with that local name and
* that namespace URI is already present in the element, it is
* replaced by the new one. Replacing an attribute node by itself has no effect.
*/
virtual AttrPtr setAttributeNodeNS(AttrPtr newAttr)
throw(DOMException) = 0;
/**
* Returns a NodeList of all the descendant Elements with a given
* local name and namespace URI in document order.
*/
virtual NodeList getElementsByTagNameNS(const DOMString& namespaceURI,
const DOMString& localName) = 0;
/**
* Returns true when an attribute with a given name is specified on
* this element or has a default value, false otherwise.
*/
virtual bool hasAttribute(const DOMString& name) = 0;
/**
* Returns true when an attribute with a given local name and namespace
* URI is specified on this element or has a default value, false otherwise.
*/
virtual bool hasAttributeNS(const DOMString& namespaceURI,
const DOMString& localName) = 0;
/**
* The type information associated with this element.
*/
virtual TypeInfo &getSchemaTypeInfo() = 0;
/**
* If the parameter isId is true, this method declares the specified
* attribute to be a user-determined ID attribute.
*/
virtual void setIdAttribute(const DOMString &name,
bool isId) throw (DOMException) = 0;
/**
* If the parameter isId is true, this method declares the specified
* attribute to be a user-determined ID attribute.
*/
virtual void setIdAttributeNS(const DOMString &namespaceURI,
const DOMString &localName,
bool isId) throw (DOMException) = 0;
/**
* If the parameter isId is true, this method declares the specified
* attribute to be a user-determined ID attribute.
*/
virtual void setIdAttributeNode(const AttrPtr idAttr,
bool isId) throw (DOMException) = 0;
//##################
//# Non-API methods
//##################
/**
*
*/
virtual ~Element() {}
};
/*#########################################################################
## Text
#########################################################################*/
/**
* The Text interface inherits from CharacterData and represents the textual
* content (termed character data in XML) of an Element or Attr. If there is no
* markup inside an element's content, the text is contained in a single object
* implementing the Text interface that is the only child of the element. If
* there is markup, it is parsed into the information items (elements, comments,
* etc.) and Text nodes that form the list of children of the element.
*/
class Text : virtual public CharacterData
{
public:
/**
* Breaks this node into two nodes at the specified offset, keeping both in the
* tree as siblings. After being split, this node will contain all the content up
* to the offset point. A new node of the same type, which contains all the
* content at and after the offset point, is returned. If the original node had a
* parent node, the new node is inserted as the next sibling of the original
* node. When the offset is equal to the length of this node, the new node has no
* data.
*/
virtual TextPtr splitText(unsigned long offset)
throw(DOMException) = 0;
/**
* Returns whether this text node contains element content whitespace, often
* abusively called "ignorable whitespace". The text node is determined to
* contain whitespace in element content during the load of the document or if
* validation occurs while using Document.normalizeDocument().
*/
virtual bool getIsElementContentWhitespace()= 0;
/**
* Returns all text of Text nodes logically-adjacent text nodes
* to this node, concatenated in document order.
*/
virtual DOMString getWholeText() = 0;
/**
* Replaces the text of the current node and all logically-adjacent text nodes
* with the specified text. All logically-adjacent text nodes are removed
* including the current node unless it was the recipient of the replacement text.
*
* This method returns the node which received the replacement text. The returned
* node is:
* o null, when the replacement text is the empty string;
* o the current node, except when the current node is read-only;
* o a new Text node of the same type (Text or CDATASection) as
* the current node inserted at the location of the replacement.
*/
virtual TextPtr replaceWholeText(const DOMString &content)
throw(DOMException) = 0;
//##################
//# Non-API methods
//##################
/**
*
*/
virtual ~Text() {}
};
/*#########################################################################
## Comment
#########################################################################*/
/**
* This interface inherits from CharacterData and represents the content of a
* comment, i.e., all the characters between the starting '<!--' and ending '-->'.
* Note that this is the definition of a comment in XML, and, in practice,
* HTML, although some HTML tools may implement the full SGML comment structure.
*/
class Comment : virtual public CharacterData
{
public:
//##################
//# Non-API methods
//##################
/**
*
*/
virtual ~Comment() {}
};
/*#########################################################################
## TypeInfo
#########################################################################*/
/**
* The TypeInfo interface represents a type referenced from Element or Attr nodes,
* specified in the schemas associated with the document. The type is a pair of
* a namespace URI and name properties, and depends on the document's schema.
*/
class TypeInfo
{
public:
/**
* The name of a type declared for the associated element or attribute,
* or null if unknown.
*/
virtual DOMString getTypeName()
{ return typeName; }
/**
* The namespace of the type declared for the associated element
* or attribute or null if the element does not have declaration or
* if no namespace information is available.
*/
virtual DOMString getTypeNamespace()
{ return typeNameSpace; }
/**
* These are the available values for the derivationMethod parameter used by the
* method TypeInfo.isDerivedFrom(). It is a set of possible types of derivation,
* and the values represent bit positions. If a bit in the derivationMethod
* parameter is set to 1, the corresponding type of derivation will be taken into
* account when evaluating the derivation between the reference type definition
* and the other type definition. When using the isDerivedFrom method, combining
* all of them in the derivationMethod parameter is equivalent to invoking the
* method for each of them separately and combining the results with the OR
* boolean function. This specification only defines the type of derivation for
* XML Schema.
*/
typedef enum
{
DERIVATION_RESTRICTION = 0x00000001,
DERIVATION_EXTENSION = 0x00000002,
DERIVATION_UNION = 0x00000004,
DERIVATION_LIST = 0x00000008
} DerivationMethod;
/**
* This method returns if there is a derivation between the reference
* type definition, i.e. the TypeInfo on which the method is being called,
* and the other type definition, i.e. the one passed as parameters.
*/
virtual bool isDerivedFrom(const DOMString &/*typeNamespaceArg*/,
const DOMString &/*typeNameArg*/,
DerivationMethod /*derivationMethod*/)
{ return false; }
//##################
//# Non-API methods
//##################
/**
*
*/
TypeInfo()
{}
/**
*
*/
TypeInfo(const TypeInfo &other)
{ assign(other); }
/**
*
*/
TypeInfo &operator=(const TypeInfo &other)
{ assign(other); return *this; }
/**
*
*/
virtual ~TypeInfo() {}
private:
void assign(const TypeInfo &other)
{
typeName = other.typeName;
typeNameSpace = other.typeNameSpace;
}
DOMString typeName;
DOMString typeNameSpace;
};
/*#########################################################################
## UserDataHandler
#########################################################################*/
/**
* When associating an object to a key on a node using Node.setUserData() the
* application can provide a handler that gets called when the node the object is
* associated to is being cloned, imported, or renamed. This can be used by the
* application to implement various behaviors regarding the data it associates to
* the DOM nodes. This interface defines that handler.
*/
class UserDataHandler
{
public:
/**
* An integer indicating the type of operation being performed on a node.
*/
typedef enum
{
NODE_CLONED = 1,
NODE_IMPORTED = 2,
NODE_DELETED = 3,
NODE_RENAMED = 4,
NODE_ADOPTED = 5
} OperationType;
/**
* This method is called whenever the node for which this handler
* is registered is imported or cloned.
*/
virtual void handle(unsigned short operation,
const DOMString &key,
const DOMUserData *data,
const NodePtr src,
const NodePtr dst) =0;
//##################
//# Non-API methods
//##################
/**
*
*/
virtual ~UserDataHandler() {}
};
/*#########################################################################
## DOMError
#########################################################################*/
/**
* DOMError is an interface that describes an error.
*/
class DOMError
{
public:
/**
* An integer indicating the severity of the error.
*/
typedef enum
{
SEVERITY_WARNING = 1,
SEVERITY_ERROR = 2,
SEVERITY_FATAL_ERROR = 3
} ErrorSeverity;
/**
* The severity of the error, either SEVERITY_WARNING, SEVERITY_ERROR,
* or SEVERITY_FATAL_ERROR.
*/
virtual unsigned short getSeverity() =0;
/**
* An implementation specific string describing the error that occurred.
*/
virtual DOMString getMessage() =0;
/**
* A DOMString indicating which related data is expected in relatedData.
* Users should refer to the specification of the error in order to find
* its DOMString type and relatedData definitions if any.
*/
virtual DOMString getType() =0;
/**
* The related platform dependent exception if any.
*/
virtual DOMObject *getRelatedException() =0;
/**
* The related DOMError.type dependent data if any.
*/
virtual DOMObject *getRelatedData() =0;
/**
* The location of the error.
*/
virtual DOMLocator *getLocation() =0;
//##################
//# Non-API methods
//##################
/**
*
*/
virtual ~DOMError() {}
};
/*#########################################################################
## DOMErrorHandler
#########################################################################*/
/**
* DOMErrorHandler is a callback interface that the DOM implementation can call
* when reporting errors that happens while processing XML data, or when doing
* some other processing (e.g. validating a document). A DOMErrorHandler object
* can be attached to a Document using the "error-handler" on the
* DOMConfiguration interface. If more than one error needs to be reported during
* an operation, the sequence and numbers of the errors passed to the error
* handler are implementation dependent.
*/
class DOMErrorHandler
{
public:
/**
* This method is called on the error handler when an error occurs.
* If an exception is thrown from this method, it is considered to be
* equivalent of returning true.
*/
virtual bool handleError(const DOMError *error) =0;
//##################
//# Non-API methods
//##################
/**
*
*/
virtual ~DOMErrorHandler() {}
};
/*#########################################################################
## DOMLocator
#########################################################################*/
/**
* DOMLocator is an interface that describes a location (e.g. where an error occurred).
*/
class DOMLocator
{
public:
/**
* The line number this locator is pointing to, or -1 if there is
* no column number available.
*/
virtual long getLineNumber() =0;
/**
* The column number this locator is pointing to, or -1 if there is
* no column number available.
*/
virtual long getColumnNumber() =0;
/**
* The byte offset into the input source this locator is pointing to
* or -1 if there is no byte offset available.
*/
virtual long getByteOffset() =0;
/**
* The UTF-16, as defined in [Unicode] and Amendment 1 of [ISO/IEC 10646],
* offset into the input source this locator is pointing to or -1
* if there is no UTF-16 offset available.
*/
virtual long getUtf16Offset() =0;
/**
* The node this locator is pointing to, or null if no node is available.
*/
virtual NodePtr getRelatedNode() =0;
/**
* The URI this locator is pointing to, or null if no URI is available.
*/
virtual DOMString getUri() =0;
//##################
//# Non-API methods
//##################
/**
*
*/
virtual ~DOMLocator() {}
};
/*#########################################################################
## DOMConfiguration
#########################################################################*/
/**
* The DOMConfiguration interface represents the configuration of a document and
* maintains a table of recognized parameters. Using the configuration, it is
* possible to change Document.normalizeDocument() behavior, such as replacing
* the CDATASection nodes with Text nodes or specifying the type of the schema
* that must be used when the validation of the Document is requested.
* DOMConfiguration objects are also used in [DOM Level 3 Load and Save] in the
* DOMParser and DOMSerializer interfaces.
*
* Look here for a list of valid parameters:
* http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#DOMConfiguration
*/
class DOMConfiguration
{
public:
/**
* Set the value of a parameter.
*/
virtual void setParameter(const DOMString &name,
const DOMUserData *value)
throw (DOMException) =0;
/**
* Return the value of a parameter if known.
*/
virtual DOMUserData *getParameter(const DOMString &name)
throw (DOMException) =0;
/**
* Check if setting a parameter to a specific value is supported.
*/
virtual bool canSetParameter(const DOMString &name,
const DOMUserData *data) =0;
/**
* The list of the parameters supported by this DOMConfiguration
* object and for which at least one value can be set by the application.
* Note that this list can also contain parameter names defined outside
* this specification.
*/
virtual DOMStringList *getParameterNames() =0;
//##################
//# Non-API methods
//##################
/**
*
*/
virtual ~DOMConfiguration() {}
};
/*#########################################################################
## CDATASection
#########################################################################*/
/**
* CDATA sections are used to escape blocks of text containing characters that
* would otherwise be regarded as markup. The only delimiter that is recognized
* in a CDATA section is the "]]>" string that ends the CDATA section. CDATA
* sections cannot be nested. Their primary purpose is for including material
* such as XML fragments, without needing to escape all the delimiters.
*/
class CDATASection : virtual public Text
{
public:
//##################
//# Non-API methods
//##################
/**
*
*/
virtual ~CDATASection() {}
};
/*#########################################################################
## DocumentType
#########################################################################*/
/**
* Each Document has a doctype attribute whose value is either null or a
* DocumentType object. The DocumentType interface in the DOM Core provides an
* interface to the list of entities that are defined for the document, and
* little else because the effect of namespaces and the various XML schema
* efforts on DTD representation are not clearly understood as of this writing.
*/
class DocumentType : virtual public Node
{
public:
/**
* The name of DTD; i.e., the name immediately following the DOCTYPE keyword.
*/
virtual DOMString getName() = 0;
/**
* A NamedNodeMap containing the general entities, both external and
* internal, declared in the DTD. Parameter entities are not contained.
* Duplicates are discarded.
*/
virtual NamedNodeMap getEntities() = 0;
/**
* A NamedNodeMap containing the notations declared in the DTD. Duplicates
* are discarded. Every node in this map also implements the
* Notation interface.
*/
virtual NamedNodeMap getNotations() = 0;
/**
* The public identifier of the external subset.
*/
virtual DOMString getPublicId() = 0;
/**
* The system identifier of the external subset. This may be an
* absolute URI or not.
*/
virtual DOMString getSystemId() = 0;
/**
* The internal subset as a string, or null if there is none. This
* does not contain the delimiting square brackets.
*/
virtual DOMString getInternalSubset() = 0;
//##################
//# Non-API methods
//##################
/**
*
*/
virtual ~DocumentType() {}
};
/*#########################################################################
## Notation
#########################################################################*/
/**
* This interface represents a notation declared in the DTD. A notation either
* declares, by name, the format of an unparsed entity (see section 4.7 of the
* XML 1.0 specification [XML 1.0]), or is used for formal declaration of
* processing instruction targets (see section 2.6 of the XML 1.0 specification
* [XML 1.0]). The nodeName attribute inherited from Node is set to the declared
* name of the notation.
*/
class Notation : virtual public Node
{
public:
/**
* The public identifier of this notation. If the public identifier was
* not specified, this is null.
*/
virtual DOMString getPublicId() = 0;
/**
* The system identifier of this notation. If the system identifier was
* not specified, this is null. This may be an absolute URI or not.
*/
virtual DOMString getSystemId() = 0;
//##################
//# Non-API methods
//##################
/**
*
*/
virtual ~Notation() {}
};
/*#########################################################################
## Entity
#########################################################################*/
/**
* This interface represents a known entity, either parsed or unparsed, in an XML
* document. Note that this models the entity itself not the entity declaration.
*/
class Entity : virtual public Node
{
public:
/**
* The public identifier associated with the entity if specified,
* and null otherwise.
*/
virtual DOMString getPublicId() = 0;
/**
* The system identifier associated with the entity if specified,
* and null otherwise. This may be an absolute URI or not.
*/
virtual DOMString getSystemId() = 0;
/**
* For unparsed entities, the name of the notation for the entity.
* For parsed entities, this is null.
*/
virtual DOMString getNotationName() = 0;
/**
* An attribute specifying the encoding used for this entity at the
* time of parsing, when it is an external parsed entity. This is null
* if it an entity from the internal subset or if it is not known.
*/
virtual DOMString getInputEncoding() = 0;
/**
* An attribute specifying, as part of the text declaration, the encoding
* of this entity, when it is an external parsed entity. This is null otherwise.
*/
virtual DOMString getXmlEncoding() = 0;
/**
* An attribute specifying, as part of the text declaration, the version
* number of this entity, when it is an external parsed entity.
* This is null otherwise.
*/
virtual DOMString getXmlVersion() = 0;
//##################
//# Non-API methods
//##################
/**
*
*/
virtual ~Entity() {}
};
/*#########################################################################
## EntityReference
#########################################################################*/
/**
* EntityReference nodes may be used to represent an entity reference in the tree.
*/
class EntityReference : virtual public Node
{
public:
//##################
//# Non-API methods
//##################
/**
*
*/
virtual ~EntityReference() {}
};
/*#########################################################################
## ProcessingInstruction
#########################################################################*/
/**
* The ProcessingInstruction interface represents a "processing instruction",
* used in XML as a way to keep processor-specific information in the text of the
* document.
*/
class ProcessingInstruction : virtual public Node
{
public:
/**
* The target of this processing instruction. XML defines this as being
* the first token following the markup that begins the processing instruction.
*/
virtual DOMString getTarget() = 0;
/**
* The content of this processing instruction. This is from the first non
* white space character after the target to the character immediately
* preceding the ?>.
*/
virtual DOMString getData() = 0;
/**
* Sets the content above.
*/
virtual void setData(const DOMString& val) throw(DOMException) = 0;
//##################
//# Non-API methods
//##################
/**
*
*/
virtual ~ProcessingInstruction() {}
};
/*#########################################################################
## DocumentFragment
#########################################################################*/
/**
* DocumentFragment is a "lightweight" or "minimal" Document object. It is very
* common to want to be able to extract a portion of a document's tree or to
* create a new fragment of a document. Imagine implementing a user command like
* cut or rearranging a document by moving fragments around. It is desirable to
* have an object which can hold such fragments and it is quite natural to use a
* Node for this purpose. While it is true that a Document object could fulfill
* this role, a Document object can potentially be a heavyweight object,
* depending on the underlying implementation. What is really needed for this is
* a very lightweight object. DocumentFragment is such an object.
*/
class DocumentFragment : virtual public Node
{
public:
//##################
//# Non-API methods
//##################
/**
*
*/
virtual ~DocumentFragment() {}
};
/*#########################################################################
## Document
#########################################################################*/
/**
* From the spec:
*
* The Document interface represents the entire HTML or XML document.
* Conceptually, it is the root of the document tree, and provides the primary
* access to the document's data.
*
* Since elements, text nodes, comments, processing instructions, etc. cannot
* exist outside the context of a Document, the Document interface also contains
* the factory methods needed to create these objects. The Node objects created
* have a ownerDocument attribute which associates them with the Document within
* whose context they were created.
*
*/
class Document : virtual public Node
{
public:
/**
* The Document Type Declaration (see DocumentType) associated with this document.
*/
virtual DocumentTypePtr getDoctype() = 0;
/**
* The DOMImplementation object that handles this document. A DOM application
* may use objects from multiple implementations.
*/
virtual DOMImplementation *getImplementation() = 0;
/**
* This is a convenience attribute that allows direct access to the child
* node that is the document element of the document.
*/
virtual ElementPtr getDocumentElement() = 0;
/**
* Creates an element of the type specified.
*/
virtual ElementPtr createElement(const DOMString& tagName)
throw(DOMException) = 0;
/**
* Creates a new, empty DocumentFragment
*/
virtual DocumentFragmentPtr createDocumentFragment() = 0;
/**
* Creates an Text node with the text data specified.
*/
virtual TextPtr createTextNode(const DOMString& text) = 0;
/**
* Creates a new Comment node with the argument text
*/
virtual CommentPtr createComment(const DOMString& text) = 0;
/**
* Creates a new CDATASection node with the argument text
*/
virtual CDATASectionPtr createCDATASection(const DOMString& text)
throw(DOMException) = 0;
/**
* Creates a new ProcessingInstruction
*/
virtual ProcessingInstructionPtr
createProcessingInstruction(const DOMString& target,
const DOMString& data)
throw(DOMException) = 0;
/**
* Creates a new Attr with the given name, but no value.
*/
virtual AttrPtr createAttribute(const DOMString& name)
throw(DOMException) = 0;
/**
* Creates a new EntityReference
*/
virtual EntityReferencePtr createEntityReference(const DOMString& name)
throw(DOMException) = 0;
/**
* Searches the Document in document order for all elements with the given
* tag name
*/
virtual NodeList getElementsByTagName(const DOMString& tagname) = 0;
/**
* Imports a node from another document to this document, without altering or
* removing the source node from the original document; this method creates a new
* copy of the source node. The returned node has no parent; (parentNode is
* null). For all nodes, importing a node creates a node object owned by the
* importing document, with attribute values identical to the source node's
* nodeName and nodeType, plus the attributes related to namespaces (prefix,
* localName, and namespaceURI). As in the cloneNode operation, the source node
* is not altered. User data associated to the imported node is not carried over.
* However, if any UserDataHandlers has been specified along with the associated
* data these handlers will be called with the appropriate parameters before this
* method returns. Additional information is copied as appropriate to the
* nodeType, attempting to mirror the behavior expected if a fragment of XML or
* HTML source was copied from one document to another, recognizing that the two
* documents may have different DTDs in the XML case. The following list
* describes the specifics for each type of node.
*/
virtual NodePtr importNode(const NodePtr importedNode,
bool deep)
throw(DOMException) = 0;
/**
* Creates a new Element with the given namespace and qualifiedName.
* Use "" for no namespace
*/
virtual ElementPtr createElementNS(const DOMString& namespaceURI,
const DOMString& qualifiedName)
throw(DOMException) = 0;
/**
* Creates a new Attr with the given namespace and qualifiedName.
*/
virtual AttrPtr createAttributeNS(const DOMString& namespaceURI,
const DOMString& qualifiedName)
throw(DOMException) = 0;
/**
* Searches the Document in document order for all elements with the given
* namespace and tag name
*/
virtual NodeList getElementsByTagNameNS(const DOMString& namespaceURI,
const DOMString& localName) = 0;
/**
* Gets the element with the given id if it exists, else null.
*/
virtual ElementPtr getElementById(const DOMString& elementId) = 0;
/**
* Return the input encoding of this Document
*/
virtual DOMString getInputEncoding() = 0;
/**
* Return the XML encoding of this Document
*/
virtual DOMString getXmlEncoding() = 0;
/**
* An attribute specifying, as part of the XML declaration, whether
* this document is standalone. This is false when unspecified.
*/
virtual bool getXmlStandalone() = 0;
/**
* Sets whether this is a standalone XML document. No validation is
* done here.
*/
virtual void setXmlStandalone(bool val) throw (DOMException) = 0;
/**
* Gets the version (1.0, 1.1, etc) of this document.
*/
virtual DOMString getXmlVersion() = 0;
/**
* Sets the XML version of this document.
*/
virtual void setXmlVersion(const DOMString &version)
throw (DOMException) = 0;
/**
* An attribute specifying whether error checking is enforced or not. When set to
* false, the implementation is free to not test every possible error case
* normally defined on DOM operations, and not raise any DOMException on DOM
* operations or report errors while using Document.normalizeDocument(). In case
* of error, the behavior is undefined. This attribute is true by default.
*/
virtual bool getStrictErrorChecking() = 0;
/**
* Sets the value described above.
*/
virtual void setStrictErrorChecking(bool val) = 0;
/**
* Gets the document URI (the base location) of this Document.
*/
virtual DOMString getDocumentURI() = 0;
/**
* Sets the document URI (the base location) of this Document to the
* argument uri.
*/
virtual void setDocumentURI(const DOMString &uri) = 0;
/**
* Attempts to adopt a node from another document to this document. If supported,
* it changes the ownerDocument of the source node, its children, as well as the
* attached attribute nodes if there are any. If the source node has a parent it
* is first removed from the child list of its parent. This effectively allows
* moving a subtree from one document to another (unlike importNode() which
* create a copy of the source node instead of moving it). When it fails,
* applications should use Document.importNode() instead. Note that if the
* adopted node is already part of this document (i.e. the source and target
* document are the same), this method still has the effect of removing the
* source node from the child list of its parent, if any.
*/
virtual NodePtr adoptNode(const NodePtr source) throw (DOMException) = 0;
/**
* Get the configuration item associated with this Document
*/
virtual DOMConfiguration *getDomConfig() = 0;
/**
* This method acts as if the document was going through a save and load cycle,
* putting the document in a "normal" form. As a consequence, this method updates
* the replacement tree of EntityReference nodes and normalizes Text nodes, as
* defined in the method Node.normalize(). Otherwise, the actual result depends
* on the features being set on the Document.domConfig object and governing what
* operations actually take place. Noticeably this method could also make the
* document namespace well-formed according to the algorithm described in
* Namespace Normalization, check the character normalization, remove the
* CDATASection nodes, etc. See DOMConfiguration for details.
*/
virtual void normalizeDocument() = 0;
/**
*
* Rename an existing node of type ELEMENT_NODE or ATTRIBUTE_NODE. When possible
* this simply changes the name of the given node, otherwise this creates a new
* node with the specified name and replaces the existing node with the new node
* as described below. If simply changing the name of the given node is not
* possible, the following operations are performed: a new node is created, any
* registered event listener is registered on the new node, any user data
* attached to the old node is removed from that node, the old node is removed
* from its parent if it has one, the children are moved to the new node, if the
* renamed node is an Element its attributes are moved to the new node, the new
* node is inserted at the position the old node used to have in its parent's
* child nodes list if it has one, the user data that was attached to the old
* node is attached to the new node. When the node being renamed is an Element
* only the specified attributes are moved, default attributes originated from
* the DTD are updated according to the new element name. In addition, the
* implementation may update default attributes from other schemas. Applications
* should use Document.normalizeDocument() to guarantee these attributes are
* up-to-date. When the node being renamed is an Attr that is attached to an
* Element, the node is first removed from the Element attributes map. Then, once
* renamed, either by modifying the existing node or creating a new one as
* described above, it is put back.
*
* In addition,
* a user data event NODE_RENAMED is fired,
* when the implementation supports the feature "MutationNameEvents",
* each mutation operation involved in this method fires the appropriate
* event, and in the end the event {http://www.w3.org/2001/xml-events,
* DOMElementNameChanged} or {http://www.w3.org/2001/xml-events,
* DOMAttributeNameChanged} is fired.
*
*/
virtual NodePtr renameNode(const NodePtr n,
const DOMString &namespaceURI,
const DOMString &qualifiedName)
throw (DOMException) = 0;
//##################
//# Non-API methods
//##################
/**
*
*/
virtual ~Document() {}
};
} //namespace dom
} //namespace w3c
} //namespace org
#endif // SEEN_DOM_H
/*#########################################################################
## E N D O F F I L E
#########################################################################*/