Functions | Datatypes

Package Dom

DOM interfaces are represented as generic references to different implementations of the DOM spec. They are parameterized by Node that supports various specializatins and instantiations. Of them, the most important is xmlnode that corresponds to the current C implementation

These generic references do not have a NULL like value. Any implementation should never create a reference with no state (like NULL). If there is need to signal that something has no state, an exception should be thrown.

Many methods might throw the SYNTAX_ERR exception, if the DOM tree is incorrectly formed, or UNDEFINED_ERR, in the case of wrong parameters or unexpected NULL pointers . If these are the only errors that a particular method might throw, it is not reflected in the method signature.

Actual DOM trees do NOT dependent on the context (TCtx). However, manipulations on DOM trees in the current, xmlctx based implementation require access to the current context (TCtx). This is accomplished by passing the context pointer to the constructor of DOMImplRef. In multithreaded environment DOMImplRef is always created in the thread context and, so, has the pointer to the right context.

DOMImplRef providea a way to create DOM trees. DomImplRef is a reference to the actual DOMImplementation object that is created when a regular, non-copy constructor of DomImplRef is invoked. This works well in multithreaded environment where DOM trees need to be shared, and each thread has a separate TCtx associated with it. This works equally well in a single threaded environment.

DOMString is only one of encodings supported by Oracle implementations. The support of other encodings is Oracle's extension. The oratext* data type is used for all encodings.

Interfaces in this package represent DOM level 2 Core interfaces according to http://www.w3.org/TR/DOM-Level-2-Core/core.html

Member Function Index
Interface AttrRef (reference to Attribute nodes)
Interface CDATASectionRef (reference to CDATASection nodes)
Interface CharacterDataRef
Interface CommentRef (reference to Comment nodes)
Interface DOMException (Exception class for DOM operations)
Interface DOMImplRef (reference to DOMImplementation)
Interface DOMImplementation (handles DOM trees)
Interface DocumentFragmentRef (reference to Fragment nodes)
Interface DocumentRange (DOM 2 interface)
Interface DocumentRef (reference to Document nodes)
Interface DocumentTraversal (DOM 2 interface)
Interface DocumentTypeRef (reference to DTD nodes)
Interface ElementRef (reference to Element nodes)
Interface EntityRef (reference to Entity nodes)
Interface EntityReferenceRef (reference to EntityReference nodes)
Interface NamedNodeMap (represents named node maps)
Interface NamedNodeMapRef (reference to a node map )
Interface NodeFilter (DOM 2 Node Filter)
Interface NodeIterator (DOM 2 Node Iterator)
Interface NodeList (represents node lists)
Interface NodeListRef (reference to a node list)
Interface NodeRef (reference to generic DOM node)
Interface NotationRef (reference to Notation nodes)
Interface ProcessingInstructionRef (reference to PI nodes)
Interface Range (DOM 2 Range)
Interface RangeException (Exceptions for DOM 2 Range operations)
Interface TextRef (reference to Text nodes)
Interface TreeWalker (DOM 2 Tree Walker)

Member Function Index

Interface	Function	Description
`AttrRef`	`AttrRef`	Constructor
`AttrRef`	`AttrRef`	Copy constructor
`AttrRef`	`getName`	Return attribute's name
`AttrRef`	`getOwnerElement`	Return attribute's owning element
`AttrRef`	`getSpecified`	Return boolean indicating if an attribute was explicitly created
`AttrRef`	`getValue`	Return attribute's value
`AttrRef`	`setValue`	Set attribute's value
`CDATASectionRef`	`CDATASectionRef`	Constructor
`CDATASectionRef`	`CDATASectionRef`	Copy constructor
`CharacterDataRef`	`appendData`	Append data to end of node's current data
`CharacterDataRef`	`deleteData`	Remove part of node's data
`CharacterDataRef`	`freeString`	Deallocate the string allocated by substringData()
`CharacterDataRef`	`getData`	Return node's data
`CharacterDataRef`	`getLength`	Return length of node's data
`CharacterDataRef`	`insertData`	Insert string into node's current data
`CharacterDataRef`	`replaceData`	Replace part of node's data
`CharacterDataRef`	`setData`	Set node's data
`CharacterDataRef`	`substringData`	Get substring of node's data
`CommentRef`	`CommentRef`	Constructor
`CommentRef`	`CommentRef`	Copy constructor
`DOMException`	`getCode`	Get Oracle XML error code embedded in the exception
`DOMException`	`getDOMCode`	Get DOM exception code embedded in the exception
`DOMException`	`getMesLang`	Get current language (encoding) of error messages
`DOMException`	`getMessage`	Get Oracle XML error message
`DOMImplRef`	`DOMImplRef`	Constructor
`DOMImplRef`	`DOMImplRef`	Copy constructor
`DOMImplRef`	`DOMImplRef`	Copy constructor
`DOMImplRef`	`createDocument`	Create document reference
`DOMImplRef`	`createDocumentType`	Create DTD reference
`DOMImplRef`	`getImplementation`	Get DOMImplementation object associated with the document
`DOMImplRef`	`getNoMod`	Get the 'no modification allowed' flag value
`DOMImplRef`	`hasFeature`	Determine if DOM feature is implemented
`DOMImplRef`	`setContext`	Set another context to a node
`DOMImplRef`	`~DOMImplRef`	Public default destructor
`DOMImplementation`	`DOMImplementation`	Constructor
`DOMImplementation`	`getNoMod`	Get the 'no modification allowed' flag value
`DOMImplementation`	`~DOMImplementation`	Public default destructor
`DocumentFragmentRef`	`DocumentFragmentRef`	Constructor
`DocumentFragmentRef`	`DocumentFragmentRef`	Copy constructor
`DocumentRange`	`DocumentRange`	Constructor
`DocumentRange`	`createRange`	Create new range object
`DocumentRange`	`destroyRange`	Destroy range object
`DocumentRange`	`~DocumentRange`	Default destructor
`DocumentRef`	`DocumentRef`	Constructor
`DocumentRef`	`DocumentRef`	Copy constructor
`DocumentRef`	`createAttribute`	Create an attribute node
`DocumentRef`	`createAttributeNS`	Create an attribute node with namespace information
`DocumentRef`	`createCDATASection`	Create a CDATA node
`DocumentRef`	`createComment`	Create a comment node
`DocumentRef`	`createDocumentFragment`	Create a document fragment
`DocumentRef`	`createElement`	Create an element node
`DocumentRef`	`createElementNS`	Create an element node with namespace information
`DocumentRef`	`createEntityReference`	Create an entity reference node
`DocumentRef`	`createProcessingInstruction`	Create a processing instruction node
`DocumentRef`	`createTextNode`	Create a text node
`DocumentRef`	`getDoctype`	Get DTD (Document Type) associated with the document
`DocumentRef`	`getDocumentElement`	Get top-level element of this document
`DocumentRef`	`getElementById`	Get an element given its ID
`DocumentRef`	`getElementsByTagName`	Get elements in the document by tag name
`DocumentRef`	`getElementsByTagNameNS`	Get elements in the document by tag name (namespace aware version)
`DocumentRef`	`getImplementation`	Get DOMImplementation object associated with the document
`DocumentRef`	`importNode`	Import a node from another DOM
`DocumentTraversal`	`DocumentTraversal`	Constructor
`DocumentTraversal`	`createNodeIterator`	Create new iterator object
`DocumentTraversal`	`createTreeWalker`	Create new tree walker object
`DocumentTraversal`	`destroyNodeIterator`	Destroy node iterator object
`DocumentTraversal`	`destroyTreeWalker`	Destroy tree walker object
`DocumentTraversal`	`~DocumentTraversal`	Default destructor
`DocumentTypeRef`	`DocumentTypeRef`	Constructor
`DocumentTypeRef`	`DocumentTypeRef`	Copy constructor
`DocumentTypeRef`	`getEntities`	Get DTD's entities
`DocumentTypeRef`	`getInternalSubset`	Get DTD's internal subset
`DocumentTypeRef`	`getName`	Get name of DTD
`DocumentTypeRef`	`getNotations`	Get DTD's notations
`DocumentTypeRef`	`getPublicId`	Get DTD's public ID
`DocumentTypeRef`	`getSystemId`	Get DTD's system ID
`ElementRef`	`ElementRef`	Constructor
`ElementRef`	`ElementRef`	Copy constructor
`ElementRef`	`getAttribute`	Get attribute's value given its name
`ElementRef`	`getAttributeNS`	Get attribute's value given its URI and localname
`ElementRef`	`getAttributeNode`	Get the attribute node given its name
`ElementRef`	`getElementsByTagName`	Get elements with given tag name
`ElementRef`	`getTagName`	Get element's tag name
`ElementRef`	`hasAttribute`	Check if named attribute exist
`ElementRef`	`hasAttributeNS`	Check if named attribute exist (namespace aware version)
`ElementRef`	`removeAttribute`	Remove attribute with specified name
`ElementRef`	`removeAttributeNS`	Remove attribute with specified URI and local name
`ElementRef`	`removeAttributeNode`	Remove attribute node
`ElementRef`	`setAttribute`	Set new attribute for this element and /or new value
`ElementRef`	`setAttributeNS`	Set new attribute for the element and /or new value
`ElementRef`	`setAttributeNode`	Set attribute node
`EntityRef`	`EntityRef`	Constructor
`EntityRef`	`EntityRef`	Copy constructor
`EntityRef`	`getNotationName`	Get entity's notation
`EntityRef`	`getPublicId`	Get entity's public ID
`EntityRef`	`getSystemId`	Get entity's system ID
`EntityRef`	`getType`	Get entity's type
`EntityReferenceRef`	`EntityReferenceRef`	Constructor
`EntityReferenceRef`	`EntityReferenceRef`	Copy constructor
`NamedNodeMapRef`	`NamedNodeMapRef`	Constructor
`NamedNodeMapRef`	`NamedNodeMapRef`	Copy constructor
`NamedNodeMapRef`	`getLength`	Get map's length
`NamedNodeMapRef`	`getNamedItem`	Get item given its name
`NamedNodeMapRef`	`getNamedItemNS`	Get item given its namespace URI and local name
`NamedNodeMapRef`	`item`	Get item given its index
`NamedNodeMapRef`	`removeNamedItem`	Remove an item given its name
`NamedNodeMapRef`	`removeNamedItemNS`	Remove the item from the map
`NamedNodeMapRef`	`setNamedItem`	Add new item to the map
`NamedNodeMapRef`	`setNamedItemNS`	Set named item to the map
`NodeFilter`	`acceptNode`	Execute it for a given node and use its return value
`NodeIterator`	`adjustCtx`	Attach this iterator to the another context
`NodeIterator`	`detach`	invalidate the iterator
`NodeIterator`	`nextNode`	Go to the next node
`NodeIterator`	`previousNode`	Go to the previous node
`NodeListRef`	`NodeListRef`	Constructor
`NodeListRef`	`NodeListRef`	Copy constructor
`NodeListRef`	`getLength`	Get list's length
`NodeListRef`	`item`	Get item given its index
`NodeRef`	`NodeRef`	Constructor
`NodeRef`	`NodeRef`	Copy constructor
`NodeRef`	`appendChild`	Append new child to node's list of children
`NodeRef`	`cloneNode`	Clone this node
`NodeRef`	`getAttributes`	Get attributes of this node
`NodeRef`	`getChildNodes`	Get children of this node
`NodeRef`	`getFirstChild`	Get the first child node of this node
`NodeRef`	`getLastChild`	Get the last child node of this node
`NodeRef`	`getLocalName`	Get local name of this node
`NodeRef`	`getNamespaceURI`	Get namespace URI of this node as a NULL-terminated string
`NodeRef`	`getNextSibling`	Get the next sibling node of this node
`NodeRef`	`getNoMod`	Tests if no modifications are allowed for this node
`NodeRef`	`getNodeName`	Get node's name as NULL-terminated string
`NodeRef`	`getNodeType`	get DOMNodeType of the node
`NodeRef`	`getNodeValue`	Get node's value as NULL-terminated string
`NodeRef`	`getOwnerDocument`	Get the owner document of this node
`NodeRef`	`getParentNode`	Get parent node of this node
`NodeRef`	`getPrefix`	Get namespace prefix of this node
`NodeRef`	`getPreviousSibling`	Get the previous sibling node of this node
`NodeRef`	`hasAttributes`	Tests if this node has attributes
`NodeRef`	`hasChildNodes`	Test if this node has children
`NodeRef`	`insertBefore`	Insert new child into node's list of children
`NodeRef`	`isSupported`	Tests if specified feature is supported by the implementation
`NodeRef`	`markToDelete`	Sets the mark to delete the referenced node
`NodeRef`	`normalize`	Merge adjacent text nodes
`NodeRef`	`removeChild`	Remove an existing child node
`NodeRef`	`replaceChild`	Replace an existing child of a node
`NodeRef`	`resetNode`	Reset NodeRef to reference another node
`NodeRef`	`setNodeValue`	Set node's value as NULL-terminated string
`NodeRef`	`setPrefix`	Set namespace prefix of this node
`NodeRef`	`~NodeRef`	Public default destructor
`NotationRef`	`NotationRef`	Constructor
`NotationRef`	`NotationRef`	Copy constructor
`NotationRef`	`getPublicId`	Get publicId
`NotationRef`	`getSystemId`	Get systemId
`ProcessingInstructionRef`	`ProcessingInstructionRef`	Constructor
`ProcessingInstructionRef`	`ProcessingInstructionRef`	Copy constructor
`ProcessingInstructionRef`	`getData`	Get processing instruction's data
`ProcessingInstructionRef`	`getTarget`	Get processing instruction's target
`ProcessingInstructionRef`	`setData`	Set processing instruction's data
`Range`	`CompareBoundaryPoints`
`Range`	`cloneContent`
`Range`	`cloneRange`
`Range`	`deleteContents`
`Range`	`detach`	invalidate the range
`Range`	`extractContent`
`Range`	`getCollapsed`	Check if the range is collapsed
`Range`	`getCommonAncestorContainer`	Get the deepest common ancestor node
`Range`	`getEndContainer`	Get end container node
`Range`	`getEndOffset`	Get offset of the end point
`Range`	`getStartContainer`	Get start container node
`Range`	`getStartOffset`	Get offset of the start point
`Range`	`insertNode`
`Range`	`select`
`Range`	`selectNode`
`Range`	`setEnd`	Set end point
`Range`	`setEndAfter`
`Range`	`setEndBefore`
`Range`	`setStart`	Set start point
`Range`	`setStartAfter`
`Range`	`setStartBefore`
`Range`	`surroundContent`
`Range`	`toString`
`RangeException`	`getCode`	Get Oracle XML error code embedded in the exception
`RangeException`	`getMesLang`	Get current language (encoding) of error messages
`RangeException`	`getMessage`	Get Oracle XML error message
`RangeException`	`getRangeCode`	Get Range exception code embedded in the exception
`TextRef`	`TextRef`	Constructor
`TextRef`	`TextRef`	Copy constructor
`TextRef`	`splitText`	Split text node into two
`TreeWalker`	`adjustCtx`	Attach this tree walker to the another context
`TreeWalker`	`firstChild`	Get the first child of the current node
`TreeWalker`	`lastChild`	Get the last child of the current node
`TreeWalker`	`nextNode`	Get the next node
`TreeWalker`	`nextSibling`	Get the next sibling node
`TreeWalker`	`parentNode`	Get the parent of the current node
`TreeWalker`	`previousNode`	Get the previous node
`TreeWalker`	`previousSibling`	Get the previous sibling node

Interface AttrRef (reference to Attribute nodes)

Member Function Index

Function	Description
AttrRef	Constructor
AttrRef	Copy constructor
getName	Return attribute's name
getOwnerElement	Return attribute's owning element
getSpecified	Return boolean indicating if an attribute was explicitly created
getValue	Return attribute's value
setValue	Set attribute's value

Interface CDATASectionRef (reference to CDATASection nodes)

Member Function Index

Function	Description
CDATASectionRef	Constructor
CDATASectionRef	Copy constructor

Interface CharacterDataRef

This interface does not have a corresponding node kind. It just introduces some common functionality for Text, Comment, and PI nodes.

Member Function Index

Function	Description
appendData	Append data to end of node's current data
deleteData	Remove part of node's data
freeString	Deallocate the string allocated by substringData()
getData	Return node's data
getLength	Return length of node's data
insertData	Insert string into node's current data
replaceData	Replace part of node's data
setData	Set node's data
substringData	Get substring of node's data

Interface CommentRef (reference to Comment nodes)

Member Function Index

Function	Description
CommentRef	Constructor
CommentRef	Copy constructor

Interface DOMException (Exception class for DOM operations)

DOM operations raise exceptions only when an operation is impossible to perform for DOM logic related reasons. Implementations might need to handle a wider range of error conditions. In these cases inherited XMLException functionality can be used.

Member Function Index

Function	Description
getCode	Get Oracle XML error code embedded in the exception
getDOMCode	Get DOM exception code embedded in the exception
getMesLang	Get current language (encoding) of error messages
getMessage	Get Oracle XML error message

Interface DOMImplRef (reference to DOMImplementation)

DOMImplRef is explicitly bound to a particular context. It provides access to all standard DOMImplementation functionality

Member Function Index

Function	Description
DOMImplRef	Constructor
DOMImplRef	Copy constructor
DOMImplRef	Copy constructor
createDocument	Create document reference
createDocumentType	Create DTD reference
getImplementation	Get DOMImplementation object associated with the document
getNoMod	Get the 'no modification allowed' flag value
hasFeature	Determine if DOM feature is implemented
setContext	Set another context to a node
~DOMImplRef	Public default destructor

Interface DOMImplementation (handles DOM trees)

DOMImplementation - is fundamental for manipulating DOM trees. Every DOM tree is attached to a particular DOM implementation object. Several DOM trees can be attached to the same DOM implementation object. Each DOM tree can be deleted and deallocated by deleting the document object. All DOM trees attached to a particular DOM implementation object are deleted when this object is deleted. DOMImplementation object is visible to the user directly. The user explicitly creates and deletes DOMIMplementation objects. However, the functionality of DOMImplementation is available through DOMImplRef objects only.

Member Function Index

Function	Description
DOMImplementation	Constructor
getNoMod	Get the 'no modification allowed' flag value
~DOMImplementation	Public default destructor

Interface DocumentFragmentRef (reference to Fragment nodes)

Member Function Index

Function	Description
DocumentFragmentRef	Constructor
DocumentFragmentRef	Copy constructor

Interface DocumentRange (DOM 2 interface)

This is an interface to the factory producing Range objects. It keeps track of all objects that it created and destructs them when itself is destructed.

Member Function Index

Function	Description
DocumentRange	Constructor
createRange	Create new range object
destroyRange	Destroy range object
~DocumentRange	Default destructor

Interface DocumentRef (reference to Document nodes)

Member Function Index

Function	Description
DocumentRef	Constructor
DocumentRef	Copy constructor
createAttribute	Create an attribute node
createAttributeNS	Create an attribute node with namespace information
createCDATASection	Create a CDATA node
createComment	Create a comment node
createDocumentFragment	Create a document fragment
createElement	Create an element node
createElementNS	Create an element node with namespace information
createEntityReference	Create an entity reference node
createProcessingInstruction	Create a processing instruction node
createTextNode	Create a text node
getDoctype	Get DTD (Document Type) associated with the document
getDocumentElement	Get top-level element of this document
getElementById	Get an element given its ID
getElementsByTagName	Get elements in the document by tag name
getElementsByTagNameNS	Get elements in the document by tag name (namespace aware version)
getImplementation	Get DOMImplementation object associated with the document
importNode	Import a node from another DOM

Interface DocumentTraversal (DOM 2 interface)

This is an interface to the factory producing NodeIterator and TreeWalker objects. It keeps track of all objects that it created and destructs them when itself is destructed.

Member Function Index

Function	Description
DocumentTraversal	Constructor
createNodeIterator	Create new iterator object
createTreeWalker	Create new tree walker object
destroyNodeIterator	Destroy node iterator object
destroyTreeWalker	Destroy tree walker object
~DocumentTraversal	Default destructor

Interface DocumentTypeRef (reference to DTD nodes)

Member Function Index

Function	Description
DocumentTypeRef	Constructor
DocumentTypeRef	Copy constructor
getEntities	Get DTD's entities
getInternalSubset	Get DTD's internal subset
getName	Get name of DTD
getNotations	Get DTD's notations
getPublicId	Get DTD's public ID
getSystemId	Get DTD's system ID

Interface ElementRef (reference to Element nodes)

Member Function Index

Function	Description
ElementRef	Constructor
ElementRef	Copy constructor
getAttribute	Get attribute's value given its name
getAttributeNS	Get attribute's value given its URI and localname
getAttributeNode	Get the attribute node given its name
getElementsByTagName	Get elements with given tag name
getTagName	Get element's tag name
hasAttribute	Check if named attribute exist
hasAttributeNS	Check if named attribute exist (namespace aware version)
removeAttribute	Remove attribute with specified name
removeAttributeNS	Remove attribute with specified URI and local name
removeAttributeNode	Remove attribute node
setAttribute	Set new attribute for this element and /or new value
setAttributeNS	Set new attribute for the element and /or new value
setAttributeNode	Set attribute node

Interface EntityRef (reference to Entity nodes)

Member Function Index

Function	Description
EntityRef	Constructor
EntityRef	Copy constructor
getNotationName	Get entity's notation
getPublicId	Get entity's public ID
getSystemId	Get entity's system ID
getType	Get entity's type

Interface EntityReferenceRef (reference to EntityReference nodes)

Member Function Index

Function	Description
EntityReferenceRef	Constructor
EntityReferenceRef	Copy constructor

Interface NamedNodeMap (represents named node maps)

Member Function Index

Function	Description

Interface NamedNodeMapRef (reference to a node map )

The node map referenced can be marked for deletion by the implementation and, then, is deleted when the destructor of this class is called

Member Function Index

Function	Description
NamedNodeMapRef	Constructor
NamedNodeMapRef	Copy constructor
getLength	Get map's length
getNamedItem	Get item given its name
getNamedItemNS	Get item given its namespace URI and local name
item	Get item given its index
removeNamedItem	Remove an item given its name
removeNamedItemNS	Remove the item from the map
setNamedItem	Add new item to the map
setNamedItemNS	Set named item to the map

Interface NodeFilter (DOM 2 Node Filter)

NodeFilter implementations are provided by users.

Member Function Index

Function	Description
acceptNode	Execute it for a given node and use its return value

Interface NodeIterator (DOM 2 Node Iterator)

Member Function Index

Function	Description
adjustCtx	Attach this iterator to the another context
detach	invalidate the iterator
nextNode	Go to the next node
previousNode	Go to the previous node

Interface NodeList (represents node lists)

Member Function Index

Function	Description

Interface NodeListRef (reference to a node list)

The node list referenced can be marked for deletion by the implementation and, then, is deleted when the destructor of this class is called

Member Function Index

Function	Description
NodeListRef	Constructor
NodeListRef	Copy constructor
getLength	Get list's length
item	Get item given its index

Interface NodeRef (reference to generic DOM node)

Member Function Index

Function	Description
NodeRef	Constructor
NodeRef	Copy constructor
appendChild	Append new child to node's list of children
cloneNode	Clone this node
getAttributes	Get attributes of this node
getChildNodes	Get children of this node
getFirstChild	Get the first child node of this node
getLastChild	Get the last child node of this node
getLocalName	Get local name of this node
getNamespaceURI	Get namespace URI of this node as a NULL-terminated string
getNextSibling	Get the next sibling node of this node
getNoMod	Tests if no modifications are allowed for this node
getNodeName	Get node's name as NULL-terminated string
getNodeType	get DOMNodeType of the node
getNodeValue	Get node's value as NULL-terminated string
getOwnerDocument	Get the owner document of this node
getParentNode	Get parent node of this node
getPrefix	Get namespace prefix of this node
getPreviousSibling	Get the previous sibling node of this node
hasAttributes	Tests if this node has attributes
hasChildNodes	Test if this node has children
insertBefore	Insert new child into node's list of children
isSupported	Tests if specified feature is supported by the implementation
markToDelete	Sets the mark to delete the referenced node
normalize	Merge adjacent text nodes
removeChild	Remove an existing child node
replaceChild	Replace an existing child of a node
resetNode	Reset NodeRef to reference another node
setNodeValue	Set node's value as NULL-terminated string
setPrefix	Set namespace prefix of this node
~NodeRef	Public default destructor

Interface NotationRef (reference to Notation nodes)

Member Function Index

Function	Description
NotationRef	Constructor
NotationRef	Copy constructor
getPublicId	Get publicId
getSystemId	Get systemId

Interface ProcessingInstructionRef (reference to PI nodes)

Member Function Index

Function	Description
ProcessingInstructionRef	Constructor
ProcessingInstructionRef	Copy constructor
getData	Get processing instruction's data
getTarget	Get processing instruction's target
setData	Set processing instruction's data

Interface Range (DOM 2 Range)

Member Function Index

Function	Description
CompareBoundaryPoints
cloneContent
cloneRange
deleteContents
detach	invalidate the range
extractContent
getCollapsed	Check if the range is collapsed
getCommonAncestorContainer	Get the deepest common ancestor node
getEndContainer	Get end container node
getEndOffset	Get offset of the end point
getStartContainer	Get start container node
getStartOffset	Get offset of the start point
insertNode
select
selectNode
setEnd	Set end point
setEndAfter
setEndBefore
setStart	Set start point
setStartAfter
setStartBefore
surroundContent
toString

Interface RangeException (Exceptions for DOM 2 Range operations)

Range operations raise exceptions only when an operation is impossible to perform for Range logic related reasons. Implementations might need to handle a wider range of error conditions. In these cases inherited XMLException functionality can be used.

Member Function Index

Function	Description
getCode	Get Oracle XML error code embedded in the exception
getMesLang	Get current language (encoding) of error messages
getMessage	Get Oracle XML error message
getRangeCode	Get Range exception code embedded in the exception

Interface TextRef (reference to Text nodes)

Member Function Index

Function	Description
TextRef	Constructor
TextRef	Copy constructor
splitText	Split text node into two

Interface TreeWalker (DOM 2 Tree Walker)

Member Function Index

Function	Description
adjustCtx	Attach this tree walker to the another context
firstChild	Get the first child of the current node
lastChild	Get the last child of the current node
nextNode	Get the next node
nextSibling	Get the next sibling node
parentNode	Get the parent of the current node
previousNode	Get the previous node
previousSibling	Get the previous sibling node

AttrRef

Name AttrRef

Interface AttrRef

Purpose Constructor

Prototype AttrRef( const NodeRef< Node>& node_ref, Node* nptr);

Arguments

`node_ref`	(IN)	reference to provide the context
`nptr`	(IN)	attribute node to be referenced

Returns (AttrRef) Node reference object

Description

This constructor is used to create references to a given attribute node after a call to createAttribute.

AttrRef

Name AttrRef

Interface AttrRef

Purpose Copy constructor

Prototype AttrRef( const AttrRef< Node>& nref);

Arguments

nref (IN) reference to the reference object to be copied

Returns (AttrRef) Node reference object

Description

This is a copy constructor.

getName

Name	`getName`
Interface	AttrRef
Purpose	Return attribute's name
Prototype	`oratext* getName() const;`
Arguments	`void`
Returns	`(oratext *)` name of attribute
Description	Returns the fully-qualified name of an attribute (in the data encoding) as a NULL-terminated string.

getOwnerElement

Name	`getOwnerElement`
Interface	AttrRef
Purpose	Return attribute's owning element
Prototype	`Node* getOwnerElement();`
Arguments	`void`
Returns	`(Node*)` attribute's owning element node.
Description	Returns attribute's owning element

getSpecified

Name	`getSpecified`
Interface	AttrRef
Purpose	Return boolean indicating if an attribute was explicitly created
Prototype	`boolean getSpecified() const;`
Arguments	`void`
Returns	`(boolean)` attribute's "specified" value
Description	Returns the 'specified' value for an attribute. If the attribute was explicitly given a value in the original document, it is TRUE; otherwise, it is FALSE. If the node is not an attribute, returns FALSE. If the user sets attribute's value through DOM, its 'specified' value will be TRUE.

getValue

Name	`getValue`
Interface	AttrRef
Purpose	Return attribute's value
Prototype	`oratext* getValue() const;`
Arguments	`void`
Returns	`(oratext*)` attribute's value
Description	Returns the "value" (character data) of an attribute (in the data encoding) as NULL-terminated string. Character and general entities will have been replaced.

setValue

Name setValue

Interface AttrRef

Purpose Set attribute's value

Prototype void setValue( oratext* data) throw (DOMException);

Arguments

data (IN) new value of attribute

Returns (void)

Description

Sets the given attribute's value to data. The new value must be in the data encoding. It is not verified, converted, or checked. The attribute's 'specified' flag will be TRUE after setting a new value.

CDATASectionRef

Name CDATASectionRef

Interface CDATASectionRef

Purpose Constructor

Prototype CDATASectionRef( const NodeRef< Node>& node_ref, Node* nptr);

Arguments

`node_ref`	(IN)	reference to provide the context
`nptr`	(IN)	CDATASection node to be referenced

Returns (CDATASectionRef) Node reference object

Description

This constructor is used to create references to a given CDATA node after a call to createCDATASection.

CDATASectionRef

Name CDATASectionRef

Interface CDATASectionRef

Purpose Copy constructor

Prototype CDATASectionRef( const CDATASectionRef< Node>& nref);

Arguments

nref (IN) reference to the reference object to be copied

Returns (CDATASectionRef) Node reference object

Description

This is a copy constructor.

appendData

Name appendData

Interface CharacterDataRef

Purpose Append data to end of node's current data

Prototype void appendData( oratext* data) throw (DOMException);

Arguments

data (IN) data to append

Returns (void)

Description

Append a string to the end of a CharacterData node's data. The appended data should be in the data encoding. It will not be verified, converted, or checked.

deleteData

Name deleteData

Interface CharacterDataRef

Purpose Remove part of node's data

Prototype void deleteData( ub4 offset, ub4 count) throw (DOMException);

Arguments

`offset`	(IN)	character offset from which to start removing
`count`	(IN)	number of characters to delete

Returns (void)

Description

Remove a range of characters from a CharacterData node's data. The offset is zero-based, so offset zero refers to the start of the data. Both offset and count are in characters, not bytes. If the sum of offset and count exceeds the data length then all characters from offset to the end of the data are deleted.

freeString

Name freeString

Interface CharacterDataRef

Purpose Deallocate the string allocated by substringData()

Prototype void freeString( oratext* str);

Arguments

str (IN) string to free

Returns (void)

Description

Deallocates the string allocated by substringData(). It is Oracle's extension.

getData

Name	`getData`
Interface	CharacterDataRef
Purpose	Return node's data
Prototype	`oratext* getData() const;`
Arguments	`void`
Returns	`(oratext*)` node's data
Description	Returns the data for a CharacterData node (type text, comment or CDATA) in the data encoding.

getLength

Name	`getLength`
Interface	CharacterDataRef
Purpose	Return length of node's data
Prototype	`ub4 getLength() const;`
Arguments	`void`
Returns	`(ub4)` length in characters (not bytes!) of node's data
Description	Returns the length of the data for a CharacterData node (type text, comment or CDATA) in characters (not bytes!).

insertData

Name insertData

Interface CharacterDataRef

Purpose Insert string into node's current data

Prototype void insertData( ub4 offset, oratext* data) throw (DOMException);

Arguments

`offset`	(IN)	character offset at which to insert
`data`	(IN)	data to insert

Returns (void)

Description

Insert a string into a CharacterData node's data at the specified position. The inserted data must be in the data encoding. It will not be verified, converted, or checked. The offset is specified as characters, not bytes. The offset is zero-based, so inserting at offset zero prepends the data.

replaceData

Name replaceData

Interface CharacterDataRef

Purpose Replace part of node's data

Prototype void replaceData( ub4 offset, ub4 count, oratext* data) throw (DOMException);

Arguments

`offset`	(IN)	character offset from which to start replacing
`count`	(IN)	number of characters to replace
`data`	(IN)	replacement substring [data encoding]

Returns

Description

Replaces a range of characters in a CharacterData node's data with a new string. The offset is zero-based, so offset zero refers to the start of the data. The replacement data must be in the data encoding. It will not be verified, converted, or checked. The offset and count are both in characters, not bytes. If the sum of offset and count exceeds length, then all characters to the end of the data are replaced.

setData

Name setData

Interface CharacterDataRef

Purpose Set node's data

Prototype void setData( oratext* data) throw (DOMException);

Arguments

data (IN) new node's data

Returns (void)

Description

Sets data for a CharacterData node (type text, comment or CDATA), replacing the old data. The new data is not verified, converted, or checked -- it should be in the data encoding.

substringData

Name substringData

Interface CharacterDataRef

Purpose Get substring of node's data

Prototype oratext* substringData( ub4 offset, ub4 count) throw (DOMException);

Arguments

`offset`	(IN)	start offset of substring to extract
`count`	(IN)	number of characters to extract

Returns (oratext *) specified substring

Description

Returns a range of character data from a CharacterData node (type text, comment or CDATA). Since the data is in the data encoding, offset and count are in characters, not bytes. The beginning of the string is offset 0. If the sum of offset and count exceeds the length, then all characters to the end of the data are returned. The substring is permanently allocated in the context managed memory and should be explicitly deallocated by freeString().

CommentRef

Name CommentRef

Interface CommentRef

Purpose Constructor

Prototype CommentRef( const NodeRef< Node>& node_ref, Node* nptr);

Arguments

`node_ref`	(IN)	reference to provide the context
`nptr`	(IN)	comment node to be referenced

Returns (CommentRef) Node reference object

Description

This constructor is used to create references to a given comment node after a call to createComment.

CommentRef

Name CommentRef

Interface CommentRef

Purpose Copy constructor

Prototype CommentRef( const CommentRef< Node>& nref);

Arguments

nref (IN) reference to the reference object to be copied

Returns (CommentRef) Node reference object

Description

This is a copy constructor.

getCode

Name	`getCode`
Interface	DOMException
Purpose	Get Oracle XML error code embedded in the exception
Prototype	`// virtual unsigned getCode() const = 0;`
Arguments	`void`
Returns	`(unsigned)` numeric error code (0 on success)
Description	Virtual member function inherited from XMLException

getDOMCode

Name	`getDOMCode`
Interface	DOMException
Purpose	Get DOM exception code embedded in the exception
Prototype	`virtual DOMExceptionCode getDOMCode() const = 0; };`
Arguments	`void`
Returns	`(DOMExceptionCode)` exception code
Description	This is a virtual member function that defines a prototype for implementation defined member functions returning DOM exception codes, defined in DOMExceptionCode, of the exceptional situations during execution

getMesLang

Name	`getMesLang`
Interface	DOMException
Purpose	Get current language (encoding) of error messages
Prototype	`// virtual oratext* getMesLang() const = 0;`
Arguments	`void`
Returns	`(oratext*)` Current language (encoding) of error messages
Description	Virtual member function inherited from XMLException

getMessage

Name	`getMessage`
Interface	DOMException
Purpose	Get Oracle XML error message
Prototype	`// virtual oratext* getMessage() const = 0;`
Arguments	`void`
Returns	`(oratext *)` Error message
Description	Virtual member function inherited from XMLException

DOMImplRef

Name DOMImplRef

Interface DOMImplRef

Purpose Constructor

Prototype DOMImplRef( Context* ctx_ptr, DOMImplementation< Node>* impl_ptr);

Arguments

ctx_ptr (IN) context pointer

Returns (DOMImplRef) reference to the implementation object

Description

Creates reference object to DOMImplementation object in a given context. Returns reference to the implementation object.

DOMImplRef

Name DOMImplRef

Interface DOMImplRef

Purpose Copy constructor

Prototype DOMImplRef( const DOMImplRef< Context, Node>& iref);

Arguments

iref (IN) reference to the reference object to be copied

Returns (DOMImplRef) new reference to the implementation object

Description

It is needed to create other references to the implementation object; deletion flags are not copied

DOMImplRef

Name DOMImplRef

Interface DOMImplRef

Purpose Copy constructor

Prototype DOMImplRef( const DOMImplRef< Context, Node>& iref, Context* ctx_ptr);

Arguments

`iref`	(IN)	reference to the reference object to be copied
`ctx_ptr`	(IN)	different context

Returns (DOMImplRef) new reference to the implementation object

Description

It is needed to create references to the implementation object in a different context; deletion flags are not copied

createDocument

Name createDocument

Interface DOMImplRef

Purpose Create document reference

Prototype DocumentRef< Node>* createDocument( oratext* namespaceURI, oratext* qualifiedName, DocumentTypeRef< Node>& doctype) throw (DOMException);

Arguments

`namespaceURI`	(IN)	namespace URI of root element to create
`qualifiedName`	(IN)	QName of root element
`doctype`	(IN)	associated DTD node

Returns (DocumentRef< Node>*) document reference

Description

Creates document reference

createDocumentType

Name createDocumentType

Interface DOMImplRef

Purpose Create DTD reference

Prototype DocumentTypeRef< Node>* createDocumentType( oratext* qualifiedName, oratext* publicId, oratext* systemId) throw (DOMException);

Arguments

`qualifiedName`	(IN)	qualified name
`publicId`	(IN)	external subset public identifier
`systemId`	(IN)	external subset system identifier

Returns (DocumentTypeRef< Node>*) DTD reference

Description

Creates DTD reference

getImplementation

Name	`getImplementation`
Interface	DOMImplRef
Purpose	Get DOMImplementation object associated with the document
Prototype	`DOMImplementation< Node>* getImplementation() const;`
Arguments	`void`
Returns	`(DOMImplementation)` DOMImplementation reference object
Description	Returns DOMImplementation object that was used to create this document. When the DOMImplementation object is destructed, all document trees associated with it are also destructed.

getNoMod

Name	`getNoMod`
Interface	DOMImplRef
Purpose	Get the 'no modification allowed' flag value
Prototype	`boolean getNoMod() const;`
Arguments	`void`
Returns	TRUE if flag's value is TRUE, FALSE otherwise
Description	It is an Oracle extension

hasFeature

Name hasFeature

Interface DOMImplRef

Purpose Determine if DOM feature is implemented

Prototype boolean hasFeature( oratext* feature, oratext* version);

Arguments

`feature`	(IN)	package name of the feature to test.
`version`	(IN)	version # of the package name to test.

Returns (boolean) is feature implemented?

Description

Determine if a DOM feature is implemented. Returns TRUE if the feature is implemented in the specified version, FALSE otherwise.

In level 1, the legal values for package are 'HTML' and 'XML' (case-insensitive), and the version is the string "1.0". If the version is not specified, supporting any version of the feature will cause the method to return true.

DOM 1.0 features are "XML" and "HTML".

DOM 2.0 features are "Core", "XML", "HTML", "Views", "StyleSheets", "CSS", "CSS2", "Events", "UIEvents", "MouseEvents", "MutationEvents", "HTMLEvents", "Range", "Traversal"

setContext

Name setContext

Interface DOMImplRef

Purpose Set another context to a node

Prototype void setContext( NodeRef< Node>& nref, Context* ctx_ptr);

Arguments

`nref`	(IN)	node reference
`ctx_ptr`	(IN)	different context

Returns (void)

Description

It is needed to create node references in a different context

~DOMImplRef

Name	`~DOMImplRef`
Interface	DOMImplRef
Purpose	Public default destructor
Prototype	`~DOMImplRef();`
Arguments	`void`
Returns	`(void)`
Description	This is the default destructor. It cleans the reference to the implementation object. It is usually called by the environment. But it can be called by the user directly if necessary.

DOMImplementation

Name DOMImplementation

Interface DOMImplementation

Purpose Constructor

Prototype DOMImplementation( boolean no_mod);

Arguments

no_mod (IN) value of the 'no modifications allowed' flag

Returns (DOMImplementation) implementation object

Description

Creates DOMImplementation object. Sets the 'no modifications allowed' flag to the parameter value.

getNoMod

Name	`getNoMod`
Interface	DOMImplementation
Purpose	Get the 'no modification allowed' flag value
Prototype	`boolean getNoMod() const; };`
Arguments	`void`
Returns	TRUE if flag's value is TRUE, FALSE otherwise
Description	It is an Oracle extension

~DOMImplementation

Name	`~DOMImplementation`
Interface	DOMImplementation
Purpose	Public default destructor
Prototype	`~DOMImplementation();`
Arguments	`void`
Returns	`(void)`
Description	This is the default destructor. It removes all DOM trees associated with this object.

DocumentFragmentRef

Name DocumentFragmentRef

Interface DocumentFragmentRef

Purpose Constructor

Prototype DocumentFragmentRef( const NodeRef< Node>& node_ref, Node* nptr);

Arguments

`node_ref`	(IN)	reference to provide the context
`nptr`	(IN)	document fragment node to be referenced

Returns (DocumentFragmentRef) Node reference object

Description

This constructor is used to create references to a given fragment node after a call to createDocumentFragment.

DocumentFragmentRef

Name DocumentFragmentRef

Interface DocumentFragmentRef

Purpose Copy constructor

Prototype DocumentFragmentRef( const DocumentFragmentRef< Node>& nref);

Arguments

nref (IN) reference to the reference object to be copied

Returns (DocumentFragmentRef) Node reference object

Description

This is a copy constructor.

DocumentRange

Name	`DocumentRange`
Interface	DocumentRange
Purpose	Constructor
Prototype	`DocumentRange();`
Arguments	`void`
Returns	`(DocumentRange)` new factory object
Description	Constructs the factory

createRange

Name createRange

Interface DocumentRange

Purpose Create new range object

Prototype Range< Node>* createRange( DocumentRef< Node>& doc);

Arguments

doc (IN) reference to a document node

Returns (Range*) Pointer to new range

Description

destroyRange

Name destroyRange

Interface DocumentRange

Purpose Destroy range object

Prototype void destroyRange( Range< Node>* range) throw (DOMException);

Arguments

range (IN) range to be destroyed

Returns (void)

Description

~DocumentRange

Name	`~DocumentRange`
Interface	DocumentRange
Purpose	Default destructor
Prototype	`~DocumentRange();`
Arguments	`void`
Returns	`(void)`
Description

DocumentRef

Name DocumentRef

Interface DocumentRef

Purpose Constructor

Prototype DocumentRef( const NodeRef< Node>& nref, Node* nptr);

Arguments

`nref`	(IN)	reference to the object to provide the context
`nptr`	(IN)	document node to be referenced

Returns (DocumentRef) Node reference object

Description

This is a onstructor.

DocumentRef

Name DocumentRef

Interface DocumentRef

Purpose Copy constructor

Prototype DocumentRef( const DocumentRef< Node>& nref);

Arguments

nref (IN) reference to the reference object to be copied

Returns (DocumentRef) Node reference object

Description

This is a copy constructor.

createAttribute

Name createAttribute

Interface DocumentRef

Purpose Create an attribute node

Prototype Node* createAttribute( oratext* name) throw (DOMException);

Arguments

name (IN) name

Returns (Node*) New attribute node

Description

Creates an attribute node with the given name. This is the non-namespace aware function. The new attribute will have NULL namespace URI and prefix, and its local name will be the same as its name, even if the name specified is a QName. The new node is an orphan with no parent. The name is NOT copied, its pointer is just stored. The user is responsible for persistence and freeing of that data.

createAttributeNS

Name createAttributeNS

Interface DocumentRef

Purpose Create an attribute node with namespace information

Prototype Node* createAttributeNS( oratext* namespaceURI, oratext* qualifiedName) throw (DOMException);

Arguments

`namespaceURI`	(IN)
`qualifiedName`	(IN)

Returns (Node*) New attribute node

Description

Creates an attribute node with the given namespace URI and QName. The new node is an orphan with no parent. The URI and QName are NOT copied, their pointers are just stored. The user is responsible for persistence and freeing of that data.

createCDATASection

Name createCDATASection

Interface DocumentRef

Purpose Create a CDATA node

Prototype Node* createCDATASection( oratext* data) throw (DOMException);

Arguments

data (IN) data for new CDATA node

Returns (Node*) New CDATA node

Description

Creates a CDATA section node with the given initial data (which should be in the data encoding). A CDATA section is considered verbatim and is never parsed; it will not be joined with adjacent text nodes by the normalize operation. The initial data may be NULL, if provided; it is not verified, converted, or checked. The name of a CDATA node is always "#cdata-section". The new node is an orphan with no parent. The CDATA is NOT copied, its pointer is just stored. The user is responsible for persistence and freeing of that data.

createComment

Name createComment

Interface DocumentRef

Purpose Create a comment node

Prototype Node* createComment( oratext* data) throw (DOMException);

Arguments

data (IN) data for new comment node

Returns (Node*) New comment node

Description

Creates a comment node with the given initial data (which must be in the data encoding). The data may be NULL, if provided; it is not verified, converted, or checked. The name of the comment node is always "#comment". The new node is an orphan with no parent. The comment data is NOT copied, its pointer is just stored. The user is responsible for persistence and freeing of that data.

createDocumentFragment

Name	`createDocumentFragment`
Interface	DocumentRef
Purpose	Create a document fragment
Prototype	`Node* createDocumentFragment() throw (DOMException);`
Arguments	`void`
Returns	`(Node*)` new document fragment node
Description	Creates an empty Document Fragment node. A document fragment is treated specially when it is inserted into a DOM tree: the children of the fragment are inserted in order instead of the fragment node itself. After insertion, the fragment node will still exist, but have no children. The name of a fragment node is always "#document-fragment".

createElement

Name createElement

Interface DocumentRef

Purpose Create an element node

Prototype Node* createElement( oratext* tagname) throw (DOMException);

Arguments

tagname (IN) tag name

Returns (Node*) New element node

Description

Creates an element node with the given tag name (which should be in the data encoding). The new node is an orphan with no parent. The tagname is NOT copied, its pointer is just stored. The user is responsible for persistence and freeing of that data.

Note that the tag name of an element is CASE SENSITIVE. This is the non-namespace aware function: the new node will have NULL namespace URI and prefix, and its local name will be the same as its tag name, even if the tag name specified is a QName.

createElementNS

Name createElementNS

Interface DocumentRef

Purpose Create an element node with namespace information

Prototype Node* createElementNS( oratext* namespaceURI, oratext* qualifiedName) throw (DOMException);

Arguments

`namespaceURI`	(IN)
`qualifiedName`	(IN)

Returns (Node*) New element node

Description

Creates an element with the given namespace URI and QName. The new node is an orphan with no parent. The URI and QName are NOT copied, their pointers are just stored. The user is responsible for persistence and freeing of that data.

Note that element names are CASE SENSITIVE, and the QName is required though the URI may be NULL. The QName will be split into prefix and local parts. The tagName will be the full QName.

createEntityReference

Name createEntityReference

Interface DocumentRef

Purpose Create an entity reference node

Prototype Node* createEntityReference( oratext* name) throw (DOMException);

Arguments

name (IN) name

Returns (Node*) New entity reference node

Description

Creates an entity reference node; the name (which should be in the data encoding) is the name of the entity to be referenced. The named entity does not have to exist. The name is not verified, converted, or checked. The new node is an orphan with no parent. The entity reference name is NOT copied; its pointer is just stored. The user is responsible for persistence and freeing of that data.

Note that entity reference nodes are never generated by the parser; instead, entity references are expanded as encountered. On output, an entity reference node will turn into a "&name;" style reference.

createProcessingInstruction

Name createProcessingInstruction

Interface DocumentRef

Purpose Create a processing instruction node

Prototype Node* createProcessingInstruction( oratext* target, oratext* data) throw (DOMException);

Arguments

`target`	(IN)	target
`data`	(IN)	data for new PI node

Returns (Node*) New PI node

Description

Creates a processing instruction node with the given target and data (which should be in the data encoding). The data may be NULL, but the target is required and cannot be changed. The target and data are not verified, converted, or checked. The name of the node is the same as the target. The new node is an orphan with no parent. The target and data are NOT copied; their pointers are just stored. The user is responsible for persistence and freeing of that data.

createTextNode

Name createTextNode

Interface DocumentRef

Purpose Create a text node

Prototype Node* createTextNode( oratext* data) throw (DOMException);

Arguments

data (IN) data for new text node

Returns (Node*) new text node

Description

Creates a text node with the given initial data (which must be non-NULL and in the data encoding). The data may be NULL; if provided, it is not verified, converted, checked, or parsed (entities will not be expanded). The name of the node is always "#text". The new node is an orphan with no parent. The text data is NOT copied, its pointer is just stored. The user is responsible for persistence and freeing of that data.

getDoctype

Name	`getDoctype`
Interface	DocumentRef
Purpose	Get DTD (Document Type) associated with the document
Prototype	`Node* getDoctype() const;`
Arguments	`void`
Returns	`(Node*)` DTD node
Description	Returns the DTD node associated with this document. After this call, a DocumentTypeRef object needs to be created with an appropriate constructor in order to call its member functions. The DTD tree cannot be edited.

getDocumentElement

Name	`getDocumentElement`
Interface	DocumentRef
Purpose	Get top-level element of this document
Prototype	`Node* getDocumentElement() const;`
Arguments	`void`
Returns	`(Node*)` Root element
Description	Returns the root element (node) of the DOM tree. Each document has only one uppermost Element node, called the root element. If there is no root element, NULL is returned. This can happen when the document tree is being constructed.

getElementById

Name getElementById

Interface DocumentRef

Purpose Get an element given its ID

Prototype Node* getElementById( oratext* elementId);

Arguments

elementId (IN)

Returns (Node*)Element node

Description

Returns the element node which has the given ID. Throws NOT_FOUND_ERR if no element is found. The given ID should be in the data encoding or it might not match.

Note that attributes named "ID" are not automatically of type ID; ID attributes (which can have any name) must be declared as type ID in the DTD or XML schema associated with the document.

getElementsByTagName

Name getElementsByTagName

Interface DocumentRef

Purpose Get elements in the document by tag name

Prototype NodeList< Node>* getElementsByTagName( oratext* tagname) const;

Arguments

tagname (IN) tag name

Returns (NodeList< Node>*) List of nodes

Description

Returns a list of all elements in the document with a given tag name, in document order (i.e. the order in which they would be encountered in a preorder traversal of the tree). The list should be freed by the user when it is no longer needed. The list is NOT live, it is a snapshot. That is, if a new node which matched the tag name were added to the DOM after the list was returned, the list would not automatically be updated to include the node.

The special name "*" matches all tag names; a NULL name matches nothing. Note that tag names are CASE SENSITIVE, and should be in the data encoding or a mismatch might occur.

This function is not namespace aware; the full tag names are compared. If two QNames with two different prefixes both of which map to the same URI are compared, the comparison will fail.

getElementsByTagNameNS

Name getElementsByTagNameNS

Interface DocumentRef

Purpose Get elements in the document by tag name (namespace aware version)

Prototype NodeList< Node>* getElementsByTagNameNS( oratext* namespaceURI, oratext* localName);

Arguments

`namespaceURI`	(IN)
`localName`	(IN)

Returns (NodeList< Node>*) List of nodes

Description

Returns a list of all elements in the document with a given namespace URI and local name, in document order (i.e. the order in which they would be encountered in a preorder traversal of the tree). The list should be freed by the user when it is no longer needed. The list is NOT live, it is a snapshot. That is, if a new node which matches the URI and local name were added to the DOM after the list was returned, the list would not automatically be updated to include the node.

The URI and local name should be in the data encoding. The special name "*" matches all local names; a NULL local name matches nothing. Namespace URIs must always match, however, no wildcard is allowed. Note that comparisons are CASE SENSITIVE.

getImplementation

Name	`getImplementation`
Interface	DocumentRef
Purpose	Get DOMImplementation object associated with the document
Prototype	`DOMImplementation< Node>* getImplementation() const;`
Arguments	`void`
Returns	`(DOMImplementation)` DOMImplementation reference object
Description	Returns DOMImplementation object that was used to create this document. When the DOMImplementation object is destructed, all document trees associated with it are also destructed.

importNode

Name importNode

Interface DocumentRef

Purpose Import a node from another DOM

Prototype Node* importNode( NodeRef< Node>& importedNode, boolean deep) const throw (DOMException);

Arguments

`importedNode`	(IN)
`deep`	(IN)

Returns (Node*) New imported node

Description

Imports a node from one Document to another. The new node is an orphan and has no parent. The original node is not modified in any way or removed from its document; instead, a new node is created with copies of all the original node's QName, prefix, namespace URI, and local name.

The deep controls whether the children of the node are recursively imported. If FALSE, only the node itself is imported, and it will have no children. If TRUE, all descendents of the node will be imported as well, and an entire new subtree created. Elements will have only their specified attributes imported; non-specified (default) attributes are omitted. New default attributes (for the destination document) are then added. Document and DocumentType nodes cannot be imported.

DocumentTraversal

Name	`DocumentTraversal`
Interface	DocumentTraversal
Purpose	Constructor
Prototype	`DocumentTraversal();`
Arguments	`void`
Returns	`(DocumentTraversal)` new factory object
Description	Constructs the factory

createNodeIterator

Name createNodeIterator

Interface DocumentTraversal

Purpose Create new iterator object

Prototype NodeIterator< Node>* createNodeIterator( NodeRef< Node>& root, WhatToShowCode whatToShow, boolean entityReferenceExpansion) throw (DOMException);

Arguments

`root`	(IN)	root of subtree to iterate on
`whatToShow`	(IN)	node types filter
`filter`	(IN)	user defined node filter
`entityReferenceExpansion`	(IN)	expand entity references if TRUE

Returns (NodeIterator*) Pointer to new iterator

Description

createTreeWalker

Name createTreeWalker

Interface DocumentTraversal

Purpose Create new tree walker object

Prototype TreeWalker< Node>* createTreeWalker( NodeRef< Node>& root, WhatToShowCode whatToShow, boolean entityReferenceExpansion) throw (DOMException);

Arguments

`root`	(IN)	root of subtree to traverse
`whatToShow`	(IN)	node types filter
`filter`	(IN)	user defined node filter
`entityReferenceExpansion`	(IN)	expand entity references if TRUE

Returns (TreeWalker*) Pointer to new tree walker

Description

destroyNodeIterator

Name destroyNodeIterator

Interface DocumentTraversal

Purpose Destroy node iterator object

Prototype void destroyNodeIterator( NodeIterator< Node>* iter) throw (DOMException);

Arguments

iter (IN) iterator to be destroyed

Returns (void)

Description

destroyTreeWalker

Name destroyTreeWalker

Interface DocumentTraversal

Purpose Destroy tree walker object

Prototype void destroyTreeWalker( TreeWalker< Node>* walker) throw (DOMException);

Arguments

walker (IN) tree walker to be destroyed

Returns (void)

Description

~DocumentTraversal

Name	`~DocumentTraversal`
Interface	DocumentTraversal
Purpose	Default destructor
Prototype	`~DocumentTraversal();`
Arguments	`void`
Returns	`(void)`
Description

DocumentTypeRef

Name DocumentTypeRef

Interface DocumentTypeRef

Purpose Constructor

Prototype DocumentTypeRef( const NodeRef< Node>& nref, Node* nptr);

Arguments

`nref`	(IN)	reference to the object to provide the context
`nptr`	(IN)	document type node to be referenced

Returns (DocumentTypeRef) Node reference object

Description

This is a constructor.

DocumentTypeRef

Name DocumentTypeRef

Interface DocumentTypeRef

Purpose Copy constructor

Prototype DocumentTypeRef( const DocumentTypeRef< Node>& nref);

Arguments

nref (IN) reference to the reference object to be copied

Returns (DocumentTypeRef) Node reference object

Description

This is a copy constructor.

getEntities

Name	`getEntities`
Interface	DocumentTypeRef
Purpose	Get DTD's entities
Prototype	`NamedNodeMap< Node>* getEntities() const;`
Arguments	`void`
Returns	`(NamedNodeMap< Node>*)` map containing entities
Description	Returns a named node map of general entities defined by the DTD.

getInternalSubset

Name getInternalSubset

Interface DocumentTypeRef

Purpose Get DTD's internal subset

Prototype Node* getInternalSubset( oratext* name);

Arguments

name (IN) name of the element

Returns (xmlnode*) content model subtree

Description

Returns the content model for an element. If there is no DTD, returns NULL.

getName

Name	`getName`
Interface	DocumentTypeRef
Purpose	Get name of DTD
Prototype	`oratext* getName() const;`
Arguments	`void`
Returns	`(oratext*)` name of DTD
Description	Returns DTD's name (specified immediately after the `DOCTYPE` keyword)

getNotations

Name	`getNotations`
Interface	DocumentTypeRef
Purpose	Get DTD's notations
Prototype	`NamedNodeMap< Node>* getNotations() const;`
Arguments	`void`
Returns	`(NamedNodeMap< Node>*)` map containing notations
Description	Returns a named node map of notations declared by the DTD.

getPublicId

Name	`getPublicId`
Interface	DocumentTypeRef
Purpose	Get DTD's public ID
Prototype	`oratext* getPublicId() const;`
Arguments	`void`
Returns	`(oratext*)` DTD's public identifier
Description	Returns DTD's public identifier

getSystemId

Name	`getSystemId`
Interface	DocumentTypeRef
Purpose	Get DTD's system ID
Prototype	`oratext* getSystemId() const;`
Arguments	`void`
Returns	`(oratext*)` DTD's system identifier
Description	Returns DTD's system identifier

ElementRef

Name ElementRef

Interface ElementRef

Purpose Constructor

Prototype ElementRef( const NodeRef< Node>& node_ref, Node* nptr);

Arguments

`node_ref`	(IN)	reference to provide the context
`nptr`	(IN)	element node to be referenced

Returns (ElementRef) Node reference object

Description

This constructor is used to create references to a given element node after a call to createElement.

ElementRef

Name ElementRef

Interface ElementRef

Purpose Copy constructor

Prototype ElementRef( const ElementRef< Node>& nref);

Arguments

nref (IN) reference to the reference object to be copied

Returns (ElementRef) Node reference object

Description

This is a copy constructor.

getAttribute

Name getAttribute

Interface ElementRef

Purpose Get attribute's value given its name

Prototype oratext* getAttribute( oratext* name) const;

Arguments

name (IN) attribute's name (in data encoding)

Returns (oratext*) named attribute's value (in data encoding)

Description

Returns the value of an element's attribute (specified by name). Note that an attribute may have the empty string as its value, but cannot be NULL.

getAttributeNS

Name getAttributeNS

Interface ElementRef

Purpose Get attribute's value given its URI and localname

Prototype oratext* getAttributeNS( oratext* namespaceURI, oratext* localName);

Arguments

`namespaceURI`	(IN)	attribute's namespace URI (data encoding)
`localName`	(IN)	attribute's local name (data encoding)

Returns (oratext *) named attribute's value (in data encoding)

Description

Returns the value of an element's attribute (specified by URI and localname). Note that an attribute may have the empty string as its value, but cannot be NULL.

getAttributeNode

Name getAttributeNode

Interface ElementRef

Purpose Get the attribute node given its name

Prototype Node* getAttributeNode( oratext* name) const;

Arguments

name (IN) attribute's name (data encoding)

Returns (Node*) the attribute node

Description

Returns the attribute node given its name.

getElementsByTagName

Name getElementsByTagName

Interface ElementRef

Purpose Get elements with given tag name

Prototype NodeList< Node>* getElementsByTagName( oratext* name);

Arguments

name (IN) tag name to match (data encoding; "*" for any tag)

Returns (NodeList< Node>*) the list of elements

Description

Returns a list of all elements with a given tag name, in the order in which they would be encountered in a preorder traversal of the subtree. The tag name should be in the data encoding. The special name "*" matches all tag names; a NULL name matches nothing. Tag names are CASE SENSITIVE. This function is not namespace aware; the full tag names are compared. The returned list should be freed by the user.

getTagName

Name	`getTagName`
Interface	ElementRef
Purpose	Get element's tag name
Prototype	`oratext* getTagName() const;`
Arguments	`void`
Returns	`(oratext)` element's name [in data encoding*]
Description	Returns the tag name of an element node which is supposed to have the same value as the node name from the node interface

hasAttribute

Name hasAttribute

Interface ElementRef

Purpose Check if named attribute exist

Prototype boolean hasAttribute( oratext* name);

Arguments

name (IN) attribute's name (data encoding)

Returns (boolean) TRUE if element has attribute with given name

Description

Determines if an element has a attribute with the given name

hasAttributeNS

Name hasAttributeNS

Interface ElementRef

Purpose Check if named attribute exist (namespace aware version)

Prototype boolean hasAttributeNS( oratext* namespaceURI, oratext* localName);

Arguments

`namespaceURI`	(IN)	attribute's namespace URI (data encoding)
`localName`	(IN)	attribute's local name (data encoding)

Returns (boolean) TRUE if element has such attribute

Description

Determines if an element has a attribute with the given URI and local name

removeAttribute

Name removeAttribute

Interface ElementRef

Purpose Remove attribute with specified name

Prototype void removeAttribute( oratext* name) throw (DOMException);

Arguments

name (IN) attribute's name [data encoding]

Returns (void)

Description

Removes an attribute specified by name. The attribute is removed from the element's list of attributes, but the attribute node itself is not destroyed.

removeAttributeNS

Name removeAttributeNS

Interface ElementRef

Purpose Remove attribute with specified URI and local name

Prototype void removeAttributeNS( oratext* namespaceURI, oratext* localName) throw (DOMException);

Arguments

`namespaceURI`	(IN)	attribute's namespace URI
`localName`	(IN)	attribute's local name

Returns (void)

Description

Removes an attribute specified by URI and local name. The attribute is removed from the element's list of attributes, but the attribute node itself is not destroyed.

removeAttributeNode

Name removeAttributeNode

Interface ElementRef

Purpose Remove attribute node

Prototype Node* removeAttributeNode( AttrRef< Node>& oldAttr) throw (DOMException);

Arguments

oldAttr (IN) attribute node to remove

Returns (Node*) the attribute node (old) or NULL

Description

Removes an attribute from an element. Returns a pointer to the removed attribute or NULL

setAttribute

Name setAttribute

Interface ElementRef

Purpose Set new attribute for this element and /or new value

Prototype void setAttribute( oratext* name, oratext* value) throw (DOMException);

Arguments

`name`	(IN)	attribute's name (data encoding)
`value`	(IN)	attribute's value (data encoding)

Returns (void)

Description

Creates a new attribute for an element with the given name and value (which should be in the data encoding). If the named attribute already exists, its value is simply replaced. The name and value are not verified, converted, or checked. The value is not parsed, so entity references will not be expanded.

setAttributeNS

Name setAttributeNS

Interface ElementRef

Purpose Set new attribute for the element and /or new value

Prototype void setAttributeNS( oratext* namespaceURI, oratext* qualifiedName, oratext* value) throw (DOMException);

Arguments

`namespaceURI`	(IN)	attribute's namespace URI (data encoding)
`qualifiedName`	(IN)	attribute's qualified name (data encoding)
`value`	(IN)	attribute's value (data encoding)

Returns (void)

Description

Creates a new attribute for an element with the given URI, localname and value (which should be in the data encoding). If the named attribute already exists, its value is simply replaced. The name and value are not verified, converted, or checked. The value is not parsed, so entity references will not be expanded.

setAttributeNode

Name setAttributeNode

Interface ElementRef

Purpose Set attribute node

Prototype Node* setAttributeNode( AttrRef< Node>& newAttr) throw (DOMException);

Arguments

newAttr (IN) attribute node to add

Returns (Node*) the attribute node (old or new)

Description

Adds a new attribute to an element. If an attribute with the given name already exists, it is replaced and a pointer to the old attribute returned. If the attribute is new, it is added to the element's list and a pointer to the new attribute is returned.

EntityRef

Name EntityRef

Interface EntityRef

Purpose Constructor

Prototype EntityRef( const NodeRef< Node>& node_ref, Node* nptr);

Arguments

`node_ref`	(IN)	reference to provide the context
`nptr`	(IN)	entity node to be referenced

Returns (EntityRef) Node reference object

Description

This constructor is used to create references to a given entity node after a call to createEntity.

EntityRef

Name EntityRef

Interface EntityRef

Purpose Copy constructor

Prototype EntityRef( const EntityRef< Node>& nref);

Arguments

nref (IN) reference to the reference object to be copied

Returns (EntityRef) Node reference object

Description

This is a copy constructor.

getNotationName

Name	`getNotationName`
Interface	EntityRef
Purpose	Get entity's notation
Prototype	`oratext* getNotationName() const;`
Arguments	`void`
Returns	`(oratext*)` entity's notation
Description	For unparsed entities, returns the name of its notation (in the data encoding). For parsed entities and other node types, returns NULL.

getPublicId

Name	`getPublicId`
Interface	EntityRef
Purpose	Get entity's public ID
Prototype	`oratext* getPublicId() const;`
Arguments	`void`
Returns	`(oratext*)` entity's public identifier
Description	Returns an entity's public identifier (in the data encoding).

getSystemId

Name	`getSystemId`
Interface	EntityRef
Purpose	Get entity's system ID
Prototype	`oratext* getSystemId() const;`
Arguments	`void`
Returns	`(oratext*)` entity's system identifier
Description	Returns an entity's system identifier (in the data encoding).

getType

Name	`getType`
Interface	EntityRef
Purpose	Get entity's type
Prototype	`boolean getType() const;`
Arguments	`void`
Returns	`(boolean)` TRUE for general entity, FALSE for parameter entity
Description	Returns a boolean for an entity describing whether it is general (TRUE) or parameter (FALSE).

EntityReferenceRef

Name EntityReferenceRef

Interface EntityReferenceRef

Purpose Constructor

Prototype EntityReferenceRef( const NodeRef< Node>& node_ref, Node* nptr);

Arguments

`node_ref`	(IN)	reference to provide the context
`nptr`	(IN)	entity reference node to be referenced

Returns (EntityReferenceRef) Node reference object

Description

This constructor is used to create references to a given entity reference node after a call to createEntityReference.

EntityReferenceRef

Name EntityReferenceRef

Interface EntityReferenceRef

Purpose Copy constructor

Prototype EntityReferenceRef( const EntityReferenceRef< Node>& nref);

Arguments

nref (IN) reference to the reference object to be copied

Returns (EntityReferenceRef) Node reference object

Description

This is a copy constructor.

NamedNodeMapRef

Name NamedNodeMapRef

Interface NamedNodeMapRef

Purpose Constructor

Prototype NamedNodeMapRef( const NodeRef< Node>& node_ref, NamedNodeMap< Node>* mptr);

Arguments

`node_ref`	(IN)	node to provide the context
`mptr`	(IN)	node map to be referenced

Returns (NamedNodeMapRef) Node reference object

Description

This constructor is used to create references to a given NamedNodeMap node.

NamedNodeMapRef

Name NamedNodeMapRef

Interface NamedNodeMapRef

Purpose Copy constructor

Prototype NamedNodeMapRef( const NamedNodeMapRef< Node>& mref);

Arguments

mref (IN) reference to the reference object to be copied

Returns (NamedNodeMapRef) Node reference object

Description

This is a copy constructor.

getLength

Name	`getLength`
Interface	NamedNodeMapRef
Purpose	Get map's length
Prototype	`ub4 getLength() const;`
Arguments	`void`
Returns	`(ub4)` map's length
Description

getNamedItem

Name getNamedItem

Interface NamedNodeMapRef

Purpose Get item given its name

Prototype Node* getNamedItem( oratext* name) const;

Arguments

name (IN) item's name

Returns (Node*) pointer to the item

Description

getNamedItemNS

Name getNamedItemNS

Interface NamedNodeMapRef

Purpose Get item given its namespace URI and local name

Prototype Node* getNamedItemNS( oratext* namespaceURI, oratext* localName) const;

Arguments

`namespaceURI`	(IN)	namespace URI of the item
`localName`	(IN)	local name of th item

Returns (Node*) pointer to the item

Description

item

Name item

Interface NamedNodeMapRef

Purpose Get item given its index

Prototype Node* item( ub4 index) const;

Arguments

index (IN) item's index

Returns (Node*) pointer to the item

Description

removeNamedItem

Name removeNamedItem

Interface NamedNodeMapRef

Purpose Remove an item given its name

Prototype Node* removeNamedItem( oratext* name) throw (DOMException);

Arguments

name (IN) name of the item to be removed

Returns (Node*) pointer to the removed item

Description

removeNamedItemNS

Name removeNamedItemNS

Interface NamedNodeMapRef

Purpose Remove the item from the map

Prototype Node* removeNamedItemNS( oratext* namespaceURI, oratext* localName) throw (DOMException);

Arguments

`namespaceURI`	(IN)	namespace URI of the item
`localName`	(IN)	local name of the item

Returns (Node*) pointer to the removed item

Description

setNamedItem

Name setNamedItem

Interface NamedNodeMapRef

Purpose Add new item to the map

Prototype Node* setNamedItem( NodeRef< Node>& newItem) throw (DOMException);

Arguments

newItem (IN) item to add to the map

Returns (Node*) pointer to new item

Description

setNamedItemNS

Name setNamedItemNS

Interface NamedNodeMapRef

Purpose Set named item to the map

Prototype Node* setNamedItemNS( NodeRef< Node>& newItem) throw (DOMException);

Arguments

newItem (IN) item to be set to the map

Returns (Node*) pointer to the item

Description

acceptNode

Name acceptNode

Interface NodeFilter

Purpose Execute it for a given node and use its return value

Prototype template< typename Node> AcceptNodeCode AcceptNode( NodeRef< Node>& nref);

Arguments

nref (IN) reference to the node to be evaluated

Returns (AcceptNodeCode) result returned by the filter function

Description

This function is used as a test by NodeIterator and TreeWalker

adjustCtx

Name adjustCtx

Interface NodeIterator

Purpose Attach this iterator to the another context

Prototype void adjustCtx( NodeRef< Node>& nref);

Arguments

nref (IN) given node reference

Returns (void)

Description

Attaches this iterator to the context associated with a given node reference

detach

Name	`detach`
Interface	NodeIterator
Purpose	invalidate the iterator
Prototype	`void detach();`
Arguments	`void`
Returns	`(void)`
Description

nextNode

Name	`nextNode`
Interface	NodeIterator
Purpose	Go to the next node
Prototype	`Node* nextNode() throw (DOMException);`
Arguments	`void`
Returns	`(Node*)` pointer to the next node
Description

previousNode

Name	`previousNode`
Interface	NodeIterator
Purpose	Go to the previous node
Prototype	`Node* previousNode() throw (DOMException);`
Arguments	`void`
Returns	`(Node*)` pointer to the previous node
Description

NodeListRef

Name NodeListRef

Interface NodeListRef

Purpose Constructor

Prototype NodeListRef( const NodeRef< Node>& node_ref, NodeList< Node>* lptr);

Arguments

`node_ref`	(IN)	node to provide the context
`lptr`	(IN)	node list node to be referenced

Returns (NodeListRef) Node reference object

Description

This constructor is used to create references to a given NodeList node.

NodeListRef

Name NodeListRef

Interface NodeListRef

Purpose Copy constructor

Prototype NodeListRef( const NodeListRef< Node>& lref);

Arguments

lref (IN) reference to the reference object to be copied

Returns (NodeListRef) Node reference object

Description

This is a copy constructor.

getLength

Name	`getLength`
Interface	NodeListRef
Purpose	Get list's length
Prototype	`ub4 getLength() const;`
Arguments	`void`
Returns	`(ub4)` list's length
Description

item

Name item

Interface NodeListRef

Purpose Get item given its index

Prototype Node* item( ub4 index) const;

Arguments

index (IN) index of the item

Returns (Node*) pointer to the item

Description

NodeRef

Name NodeRef

Interface NodeRef

Purpose Constructor

Prototype NodeRef( const NodeRef< Node>& nref, Node* nptr);

Arguments

`nref`	(IN)	reference to the node reference object
`nptr`	(IN)	node to be referenced

Returns (NodeRef) Node reference object

Description

This constructor is used to create references to a given node when at least one reference to this node or another node is already available. The node deletion flag is not copied and is set to FALSE.

NodeRef

Name NodeRef

Interface NodeRef

Purpose Copy constructor

Prototype NodeRef( const NodeRef< Node>& nref);

Arguments

nref (IN) reference to the reference object to be copied

Returns (NodeRef) Node reference object

Description

This copy constructor is used to create additional references to the node when at least one reference is already available. The node deletion flag is not copied and is set to FALSE.

appendChild

Name appendChild

Interface NodeRef

Purpose Append new child to node's list of children

Prototype Node* appendChild( NodeRef& newChild) throw (DOMException);

Arguments

newChild (IN) reference to the node to add

Returns (Node*) the node appended

Description

Appends the node to the end of this node's list of children and returns the new node. If newChild is a DocumentFragment, all of its children are appended in original order; the DocumentFragment node itself is not. If newChild is already in the DOM tree, it is first removed from its current position.

cloneNode

Name cloneNode

Interface NodeRef

Purpose Clone this node

Prototype Node* cloneNode( boolean deep);

Arguments

deep (IN) indicates if children should be recursively cloned

Returns (Node*) duplicate (cloned) node

Description

Creates and returns a duplicate of this node. The duplicate node has no parent. Cloning an Element copies all attributes and their values, including those generated by the XML processor to represent defaulted attributes, but it does not copy any text it contains unless it is a deep clone, since the text is contained in a child Text node. Cloning any other type of node simply returns a copy of the node. If deep is TRUE, all children of the node are recursively cloned, and the cloned node will have cloned children; a non-deep clone will have no children. If the cloned node is not inserted into another tree or fragment, it probably should be marked, through its reference, for deletion (by the user).

getAttributes

Name	`getAttributes`
Interface	NodeRef
Purpose	Get attributes of this node
Prototype	`NamedNodeMap< Node>* getAttributes() const;`
Arguments	`void`
Returns	`(NamedNodeMap*)` NamedNodeMap of attributes
Description	Returns NamedNodeMap of attributes of this node, or NULL if it has no attributes. Only element nodes can have attribute nodes. For other node kinds, NULL is always returned. In the current implementation, the node map of child nodes is live; all changes in the original node are reflected immediately. Because of this, side effects can be present for some DOM tree manipulation styles, in particular, in multi-threaded environments.

getChildNodes

Name	`getChildNodes`
Interface	NodeRef
Purpose	Get children of this node
Prototype	`NodeList< Node>* getChildNodes() const;`
Arguments	`void`
Returns	`(NodeList*)` the list of child nodes
Description	Returns the list of child nodes, or NULL if this node has no children. Only Element, Document, DTD, and DocumentFragment nodes may have children; all other types will return NULL. In the current implementation, the list of child nodes is live; all changes in the original node are reflected immediately. Because of this, side effects can be present for some DOM tree manipulation styles, in particular, in multi-threaded environments.

getFirstChild

Name	`getFirstChild`
Interface	NodeRef
Purpose	Get the first child node of this node
Prototype	`Node* getFirstChild() const;`
Arguments	`void`
Returns	`(Node*)` the first child node, or NULL
Description	Returns the first child node, or NULL, if this node has no children

getLastChild

Name	`getLastChild`
Interface	NodeRef
Purpose	Get the last child node of this node
Prototype	`Node* getLastChild() const;`
Arguments	`void`
Returns	`(Node*)` the last child node, or NULL
Description	Returns the last child node, or NULL, if this node has no children

getLocalName

Name	`getLocalName`
Interface	NodeRef
Purpose	Get local name of this node
Prototype	`oratext* getLocalName() const;`
Arguments	`void`
Returns	`(oratext*)` local name of this node
Description	Returns local name (local part of the qualified name) of this node (in the data encoding) as a NULL-terminated string. If this node's name is not fully qualified (has no prefix), then the local name is the same as the name.

getNamespaceURI

Name	`getNamespaceURI`
Interface	NodeRef
Purpose	Get namespace URI of this node as a NULL-terminated string
Prototype	`oratext* getNamespaceURI() const;`
Arguments	`void`
Returns	`(oratext*)` namespace URI of this node
Description	Returns the namespace URI of this node (in the data encoding) as a NULL-terminated string. If the node's name is not qualified (does not contain a namespace prefix), it will have the default namespace in effect when the node was created (which may be NULL).

getNextSibling

Name	`getNextSibling`
Interface	NodeRef
Purpose	Get the next sibling node of this node
Prototype	`Node* getNextSibling() const;`
Arguments	`void`
Returns	`(Node*)` the next sibling node, or NULL
Description	Returns the next sibling node, or NULL, if this node has no next sibling

getNoMod

Name	`getNoMod`
Interface	NodeRef
Purpose	Tests if no modifications are allowed for this node
Prototype	`boolean getNoMod() const;`
Arguments	`void`
Returns	`(boolean)` TRUE if no modifications are allowed
Description	Tests if no modifications are allowed for this node and the DOM tree it belongs to. This member function is Oracle extension.

getNodeName

Name	`getNodeName`
Interface	NodeRef
Purpose	Get node's name as NULL-terminated string
Prototype	`oratext* getNodeName() const;`
Arguments	`void`
Returns	`(oratext*)` name of node in data encoding
Description	Returns the (fully-qualified) name of the node (in the data encoding) as a NULL-terminated string, for example "bar\0" or "foo:bar\0". Some node kinds have fixed names: "#text", "#cdata-section", "#comment", "#document", "#document-fragment". The name of a node cannot changed once it is created.

getNodeType

Name	`getNodeType`
Interface	NodeRef
Purpose	get DOMNodeType of the node
Prototype	`DOMNodeType getNodeType() const;`
Arguments	`void`
Returns	`(DOMNodeType)` of the node
Description	Returns DOMNodeType of the node

getNodeValue

Name	`getNodeValue`
Interface	NodeRef
Purpose	Get node's value as NULL-terminated string
Prototype	`oratext* getNodeValue() const;`
Arguments	`void`
Returns	`(oratext *)` value of node
Description	Returns the "value" (associated character data) for a node as a NULL-terminated string. Character and general entities will have been replaced. Only Attr, CDATA, Comment, PI and Text nodes have values, all other node types have NULL value.

getOwnerDocument

Name	`getOwnerDocument`
Interface	NodeRef
Purpose	Get the owner document of this node
Prototype	`Node* getOwnerDocument() const throw (DOMException);`
Arguments	`void`
Returns	`(Node*)` the owning document node
Description	Returns the document node associated with this node. It is assumed that the document node type is derived from the node type. Each node may belong to only one document, or may not be associated with any document at all, e.g. immediately after it was created on user's request. The "owning" document [node] is returned, or the WRONG_DOCUMENT_ERR exception is thrown.

getParentNode

Name	`getParentNode`
Interface	NodeRef
Purpose	Get parent node of this node
Prototype	`Node* getParentNode() const;`
Arguments	`void`
Returns	`(Node*)` the parent node, or NULL
Description	Returns the parent node, or NULL, if this node has no parent

getPrefix

Name	`getPrefix`
Interface	NodeRef
Purpose	Get namespace prefix of this node
Prototype	`oratext* getPrefix() const;`
Arguments	`void`
Returns	`(oratext*)` namespace prefix of this node
Description	Returns the namespace prefix of this node (in the data encoding) (as a NULL-terminated string). If this node's name is not fully qualified (has no prefix), NULL is returned.

getPreviousSibling

Name	`getPreviousSibling`
Interface	NodeRef
Purpose	Get the previous sibling node of this node
Prototype	`Node* getPreviousSibling() const;`
Arguments	`void`
Returns	`(Node*)` the previous sibling node, or NULL
Description	Returns the previous sibling node, or NULL, if this node has no previous siblings

hasAttributes

Name	`hasAttributes`
Interface	NodeRef
Purpose	Tests if this node has attributes
Prototype	`boolean hasAttributes() const;`
Arguments	`void`
Returns	`(boolean)` TRUE is this node is an element and has attributes
Description	Returns TRUE if this node has attributes, if it is an element. Otherwise, it returns FALSE. Note that for nodes that are not elements, it always returns FALSE.

hasChildNodes

Name	`hasChildNodes`
Interface	NodeRef
Purpose	Test if this node has children
Prototype	`boolean hasChildNodes() const;`
Arguments	`void`
Returns	`(boolean)` TRUE if this node has any children
Description	Tests if this node has children. Only Element, Document, DTD, and DocumentFragment nodes may have children.

insertBefore

Name insertBefore

Interface NodeRef

Purpose Insert new child into node's list of children

Prototype Node* insertBefore( NodeRef& newChild, NodeRef& refChild) throw (DOMException);

Arguments

`newChild`	(IN)	reference to the node to insert
`refChild`	(IN)	reference to the node to insert before

Returns (Node*) the node being inserted

Description

Inserts the node newChild before the existing child node refChild in this node. refChild must be a child of this node. If newChild is a DocumentFragment, all of its children are inserted (in the same order) before refChild; the DocumentFragment node itself is not. If newChild is already in the DOM tree, it is first removed from its current position.

isSupported

Name isSupported

Interface NodeRef

Purpose Tests if specified feature is supported by the implementation

Prototype boolean isSupported( oratext* feature, oratext* version) const;

Arguments

`feature`	(IN)	package name of the feature to test
`version`	(IN)	version # of the package name to test

Returns (boolean) TRUE is specified feature is supported

Description

Tests if the feature, specified by the arguments, is supported by the DOM implementation of this node.

markToDelete

Name	`markToDelete`
Interface	NodeRef
Purpose	Sets the mark to delete the referenced node
Prototype	`void markToDelete();`
Arguments	`void`
Returns	`(void)`
Description	Sets the mark indicating that the referenced node should be deleted at the time when destructor of this reference is called. All other references to the node become invalid. This behavior is inherited by all other reference classes. This member function is Oracle extension.

normalize

Name	`normalize`
Interface	NodeRef
Purpose	Merge adjacent text nodes
Prototype	`void normalize();`
Arguments	`void`
Returns	`(void)`
Description	"Normalizes" the subtree rooted at an element, i.e. merges adjacent Text nodes children of elements. Note that adjacent Text nodes will never be created during a normal parse, only after manipulation of the document with DOM calls.

removeChild

Name removeChild

Interface NodeRef

Purpose Remove an existing child node

Prototype Node* removeChild( NodeRef& oldChild) throw (DOMException);

Arguments

oldChild (IN) reference to the node to be removed

Returns (Node*) node removed

Description

Removes the node from this node's list of children and returns it. The node is orphaned; its parent will be NULL after removal.

replaceChild

Name replaceChild

Interface NodeRef

Purpose Replace an existing child of a node

Prototype Node* replaceChild( NodeRef& newChild, NodeRef& oldChild) throw (DOMException);

Arguments

`newChild`	(IN)	reference to new node being substituted
`oldChild`	(IN)	reference to the node to be substituted

Returns (Node*) the node replaced

Description

Replaces the child node oldChild with the new node newChild in this node's children list, and returns oldChild (which is now orphaned, with a NULL parent). If newChild is a DocumentFragment, all of its children are inserted in place of oldChild; the DocumentFragment node itself is not. If newChild is already in the DOM tree, it is first removed from its current position.

resetNode

Name resetNode

Interface NodeRef

Purpose Reset NodeRef to reference another node

Prototype void resetNode( Node* nptr);

Arguments

nptr (IN) node to be referenced

Returns (void)

Description

This function resets NodeRef to reference Node given as an argument

setNodeValue

Name setNodeValue

Interface NodeRef

Purpose Set node's value as NULL-terminated string

Prototype void setNodeValue( oratext* data) throw (DOMException);

Arguments

data (IN) node's new value

Returns (void)

Description

Sets a node's value (character data) as a NULL-terminated string. Does not allow setting the value to NULL. Only Attr, CDATA, Comment, PI, and Text nodes have values. Trying to set the value of another kind of node is a no-op. The new value must be in the data encoding! It is not verified, converted, or checked. The value is NOT copied, its pointer is just stored. The user is responsible for persistence and freeing of that data.

It throws the NO_MODIFICATION_ALLOWED_ERR exception, if no modifications are allowed, or UNDEFINED_ERR, with an appropriate Oracle XML error code (see xml.h), in the case of an implementation defined error.

setPrefix

Name setPrefix

Interface NodeRef

Purpose Set namespace prefix of this node

Prototype void setPrefix( oratext* prefix) throw (DOMException);

Arguments

prefix (IN) new namespace prefix

Returns (void)

Description

Sets the namespace prefix of this node (as NULL-terminated string). Does not verify the prefix is defined! And does not verify that the prefix is in the current data encoding. Just causes a new QName to be formed from the new prefix and the old local name.

It throws the NO_MODIFICATION_ALLOWED_ERR exception, if no modifications are allowed. Or it throws NAMESPACE_ERR if the namespaceURI of this node is null, or if the specified prefix is "xml" and the namespaceURI of this node is different from "http://www.w3.org/XML/1998/namespace", or if this node is an attribute and the specified prefix is "xmlns" and the namespaceURI of this node is different from "http://www.w3.org/2000/xmlns/". Note that the INVALID_CHARACTER_ERR exception is never thrown since it is not checked how the prefix is formed

~NodeRef

Name	`~NodeRef`
Interface	NodeRef
Purpose	Public default destructor
Prototype	`~NodeRef();`
Arguments	`void`
Returns	`(void)`
Description	This is the default destructor. It cleans the reference to the node and, if the node is marked for deletion, deletes the node. If the node was marked for deep deletion, the tree under the node is also deleted (deallocated). It is usually called by the environment. But it can be called by the user directly if necessary.

NotationRef

Name NotationRef

Interface NotationRef

Purpose Constructor

Prototype NotationRef( const NodeRef< Node>& node_ref, Node* nptr);

Arguments

`node_ref`	(IN)	reference to provide the context
`nptr`	(IN)	notation node to be referenced

Returns (NotationRef) Node reference object

Description

This constructor is used to create references to a given notation node after a call to createNotation.

NotationRef

Name NotationRef

Interface NotationRef

Purpose Copy constructor

Prototype NotationRef( const NotationRef< Node>& nref);

Arguments

nref (IN) reference to the reference object to be copied

Returns (NotationRef) Node reference object

Description

This is a copy constructor.

getPublicId

Name	`getPublicId`
Interface	NotationRef
Purpose	Get publicId
Prototype	`oratext* getPublicId() const;`
Arguments	`void`
Returns	`(oratext*)` publicId
Description

getSystemId

Name	`getSystemId`
Interface	NotationRef
Purpose	Get systemId
Prototype	`oratext* getSystemId() const;`
Arguments	`void`
Returns	`(oratext*)` systemId
Description

ProcessingInstructionRef

Name ProcessingInstructionRef

Interface ProcessingInstructionRef

Purpose Constructor

Prototype ProcessingInstructionRef( const NodeRef< Node>& node_ref, Node* nptr);

Arguments

`node_ref`	(IN)	reference to provide the context
`nptr`	(IN)	PI node to be referenced

Returns (ProcessingInstructionRef) Node reference object

Description

This constructor is used to create references to a given PI node after a call to createProcessingInstruction.

ProcessingInstructionRef

Name ProcessingInstructionRef

Interface ProcessingInstructionRef

Purpose Copy constructor

Prototype ProcessingInstructionRef( const ProcessingInstructionRef< Node>& nref);

Arguments

nref (IN) reference to the reference object to be copied

Returns (ProcessingInstructionRef) Node reference object

Description

This is a copy constructor.

getData

Name	`getData`
Interface	ProcessingInstructionRef
Purpose	Get processing instruction's data
Prototype	`oratext* getData() const;`
Arguments	`void`
Returns	`(oratext*)` processing instruction's data
Description	Returns the content (data) of a processing instruction (in the data encoding). The content is the part from the first non-whitespace character after the target until the ending "?>".

getTarget

Name	`getTarget`
Interface	ProcessingInstructionRef
Purpose	Get processing instruction's target
Prototype	`oratext* getTarget() const;`
Arguments	`void`
Returns	`(oratext*)` processing instruction's target
Description	Returns a processing instruction's target string. The target is the first token following the markup that begins the PI. All PIs must have a target, though the data part is optional.

setData

Name setData

Interface ProcessingInstructionRef

Purpose Set processing instruction's data

Prototype void setData( oratext* data) throw (DOMException);

Arguments

data (IN) processing instruction's new data

Returns (void)

Description

Sets processing instruction's data (content), which must be in the data encoding. It is not permitted to set the data to NULL. The new data is not verified, converted, or checked.

CompareBoundaryPoints

Name CompareBoundaryPoints

Interface Range

Purpose

Prototype CompareHowCode compareBoundaryPoints( unsigned short how, Range< Node>* sourceRange) throw (DOMException);

Arguments

`how`	(IN)	how to compare
`sourceRange`	(IN)	range to compare with

Returns (CompareHowCode) result of comparison

Description

cloneContent

Name	`cloneContent`
Interface	Range
Purpose
Prototype	`Node* cloneContents() throw (DOMException);`
Arguments	`void`
Returns	`(Node*)` subtree cloned
Description

cloneRange

Name	`cloneRange`
Interface	Range
Purpose
Prototype	`Range< Node>* cloneRange();`
Arguments	`void`
Returns	`(Range< Node>*)` new cloned range
Description

deleteContents

Name	`deleteContents`
Interface	Range
Purpose
Prototype	`void deleteContents() throw (DOMException);`
Arguments	`void`
Returns	`(void)`
Description

detach

Name	`detach`
Interface	Range
Purpose	invalidate the range
Prototype	`void detach();`
Arguments	`void`
Returns	`(void)`
Description	Invalidates the range. It is not recommended to use this method since it leaves the object in invalid state. The preferable way is to call the destructor.

extractContent

Name	`extractContent`
Interface	Range
Purpose
Prototype	`Node* extractContents() throw (DOMException);`
Arguments	`void`
Returns	`(Node*)` subtree extracted
Description

getCollapsed

Name	`getCollapsed`
Interface	Range
Purpose	Check if the range is collapsed
Prototype	`boolean getCollapsed() const;`
Arguments	`void`
Returns	`(boolean)` TRUE if the range is collapsed, FALSE otherwise
Description

getCommonAncestorContainer

Name	`getCommonAncestorContainer`
Interface	Range
Purpose	Get the deepest common ancestor node
Prototype	`Node* getCommonAncestorContainer() const;`
Arguments	`void`
Returns	`(Node*)` common ancestor node
Description

getEndContainer

Name	`getEndContainer`
Interface	Range
Purpose	Get end container node
Prototype	`Node* getEndContainer() const;`
Arguments	`void`
Returns	`(Node*)` end container node
Description

getEndOffset

Name	`getEndOffset`
Interface	Range
Purpose	Get offset of the end point
Prototype	`long getEndOffset() const;`
Arguments	`void`
Returns	`(long)` offset
Description

getStartContainer

Name	`getStartContainer`
Interface	Range
Purpose	Get start container node
Prototype	`Node* getStartContainer() const;`
Arguments	`void`
Returns	`(Node*)` start container node
Description

getStartOffset

Name	`getStartOffset`
Interface	Range
Purpose	Get offset of the start point
Prototype	`long getStartOffset() const;`
Arguments	`void`
Returns	`(long)` offset
Description

insertNode

Name insertNode

Interface Range

Purpose

Prototype void insertNode( NodeRef< Node>& newNode) throw (RangeException, DOMException);

Arguments

newNode (IN) node to insert

Returns (void)

Description

select

Name select

Interface Range

Purpose

Prototype void selectNodeContent( NodeRef< Node>& refNode) throw (RangeException);

Arguments

refNode (IN) reference node

Returns (void)

Description

selectNode

Name selectNode

Interface Range

Purpose

Prototype void selectNode( NodeRef< Node>& refNode) throw (RangeException);

Arguments

refNode (IN) reference node

Returns (void)

Description

setEnd

Name setEnd

Interface Range

Purpose Set end point

Prototype void setEnd( NodeRef< Node>& refNode, long offset) throw (RangeException, DOMException);

Arguments

`refNode`	(IN)	end container
`offset`	(IN)	end offset

Returns (void)

Description

setEndAfter

Name setEndAfter

Interface Range

Purpose

Prototype void setEndAfter( NodeRef< Node>& refNode) throw (RangeException); /*--------------------------------------------------------------------- NAME collapse

Arguments

refNode (IN) reference node

Returns (void)

Description

setEndBefore

Name setEndBefore

Interface Range

Purpose

Prototype void setEndBefore( NodeRef< Node>& refNode) throw (RangeException);

Arguments

refNode (IN) reference node

Returns (void)

Description

setStart

Name setStart

Interface Range

Purpose Set start point

Prototype void setStart( NodeRef< Node>& refNode, long offset) throw (RangeException, DOMException);

Arguments

`refNode`	(IN)	start container
`offset`	(IN)	start offset

Returns (void)

Description

setStartAfter

Name setStartAfter

Interface Range

Purpose

Prototype void setStartAfter( NodeRef< Node>& refNode) throw (RangeException);

Arguments

refNode (IN) reference node

Returns (void)

Description

setStartBefore

Name setStartBefore

Interface Range

Purpose

Prototype void setStartBefore( NodeRef< Node>& refNode) throw (RangeException);

Arguments

refNode (IN) reference node

Returns (void)

Description

surroundContent

Name surroundContent

Interface Range

Purpose

Prototype void surroundContents( NodeRef< Node>& newParent) throw (RangeException, DOMException);

Arguments

newParent (IN) parent node

Returns (void)

Description

toString

Name	`toString`
Interface	Range
Purpose
Prototype	`oratext* toString();`
Arguments	`void`
Returns	`(oratext*)` string representation of the range
Description

getCode

Name	`getCode`
Interface	RangeException
Purpose	Get Oracle XML error code embedded in the exception
Prototype	`// virtual unsigned getCode() const = 0;`
Arguments	`void`
Returns	`(unsigned)` numeric error code (0 on success)
Description	Virtual member function inherited from XMLException

getMesLang

Name	`getMesLang`
Interface	RangeException
Purpose	Get current language (encoding) of error messages
Prototype	`// virtual oratext* getMesLang() const = 0;`
Arguments	`void`
Returns	`(oratext*)` Current language (encoding) of error messages
Description	Virtual member function inherited from XMLException

getMessage

Name	`getMessage`
Interface	RangeException
Purpose	Get Oracle XML error message
Prototype	`// virtual oratext* getMessage() const = 0;`
Arguments	`void`
Returns	`(oratext *)` Error message
Description	Virtual member function inherited from XMLException

getRangeCode

Name	`getRangeCode`
Interface	RangeException
Purpose	Get Range exception code embedded in the exception
Prototype	`virtual RangeExceptionCode getRangeCode() const = 0; };`
Arguments	`void`
Returns	`(RangeExceptionCode)` exception code
Description	This is a virtual member function that defines a prototype for implementation defined member functions returning Range exception codes, defined in RangeExceptionCode, of the exceptional situations during execution

TextRef

Name TextRef

Interface TextRef

Purpose Constructor

Prototype TextRef( const NodeRef< Node>& node_ref, Node* nptr);

Arguments

`node_ref`	(IN)	reference to provide the context
`nptr`	()	text node to be referenced

Returns (TextRef) Node reference object

Description

This constructor is used to create references to a given text node after a call to createtext.

TextRef

Name TextRef

Interface TextRef

Purpose Copy constructor

Prototype TextRef( const TextRef< Node>& nref);

Arguments

nref (IN) reference to the reference object to be copied

Returns (TextRef) Node reference object

Description

This is a copy constructor.

splitText

Name splitText

Interface TextRef

Purpose Split text node into two

Prototype Node* splitText( ub4 offset) throw (DOMException);

Arguments

offset (IN) character offset at which to split

Returns (Node*) new node

Description

Splits a single text node into two text nodes; the original data is split between them. The offset is zero-based, and is in characters, not bytes. The original node is retained, its data is just truncated. A new text node is created which contains the remainder of the original data, and is inserted as the next sibling of the original. The new text node is returned.

adjustCtx

Name adjustCtx

Interface TreeWalker

Purpose Attach this tree walker to the another context

Prototype void adjustCtx( NodeRef< Node>& nref);

Arguments

nref (IN) given node reference

Returns (void)

Description

Attaches this tree walker to the context associated with a given node reference

firstChild

Name	`firstChild`
Interface	TreeWalker
Purpose	Get the first child of the current node
Prototype	`Node* firstChild();`
Arguments	`void`
Returns	`(Node*)` pointer to first child node
Description

lastChild

Name	`lastChild`
Interface	TreeWalker
Purpose	Get the last child of the current node
Prototype	`Node* lastChild();`
Arguments	`void`
Returns	`(Node*)` pointer to last child node
Description

nextNode

Name	`nextNode`
Interface	TreeWalker
Purpose	Get the next node
Prototype	`Node* nextNode();`
Arguments	`void`
Returns	`(Node*)` pointer to the next node
Description

nextSibling

Name	`nextSibling`
Interface	TreeWalker
Purpose	Get the next sibling node
Prototype	`Node* nextSibling();`
Arguments	`void`
Returns	`(Node*)` pointer to the next sibling node
Description

parentNode

Name	`parentNode`
Interface	TreeWalker
Purpose	Get the parent of the current node
Prototype	`Node* parentNode();`
Arguments	`void`
Returns	`(Node*)` pointer to the parent node
Description

previousNode

Name	`previousNode`
Interface	TreeWalker
Purpose	Get the previous node
Prototype	`Node* previousNode();`
Arguments	`void`
Returns	`(Node*)` pointer to te previous node
Description

previousSibling

Name	`previousSibling`
Interface	TreeWalker
Purpose	Get the previous sibling node
Prototype	`Node* previousSibling();`
Arguments	`void`
Returns	`(Node*)` pointer to the previous sibling node
Description