hasFeature on
* DOMImplementation.
* @param version This is the version number of the feature to test. In
* Level 2, version 1, this is the string "2.0". If the version is not
* specified, supporting any version of the feature will cause the
* method to return true.
*
* @return Returns false
* @since DOM Level 2
*/
public boolean isSupported(String feature, String version)
{
return false;
}
/**
* Unimplemented. See org.w3c.dom.Node
*
* @return null
*/
public String getNamespaceURI()
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getNamespaceURI not supported!");
return null;
}
/**
* Unimplemented. See org.w3c.dom.Node
*
* @return null
*/
public String getPrefix()
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getPrefix not supported!");
return null;
}
/**
* Unimplemented. See org.w3c.dom.Node
*
* @param prefix Prefix to set for this node
*
* @throws DOMException
*/
public void setPrefix(String prefix) throws DOMException
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"setPrefix not supported!");
}
/**
* Unimplemented. See org.w3c.dom.Node
*
* @return null
*/
public String getLocalName()
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED); //"getLocalName not supported!");
return null;
}
/**
* Unimplemented. See org.w3c.dom.Document
*
* @return null
*/
public DocumentType getDoctype()
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
return null;
}
/**
* Unimplemented. See org.w3c.dom.Document
*
* @return null
*/
public DOMImplementation getImplementation()
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
return null;
}
/**
* Unimplemented. See org.w3c.dom.Document
*
* @return null
*/
public Element getDocumentElement()
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
return null;
}
/**
* Unimplemented. See org.w3c.dom.Document
*
* @param tagName Element tag name
*
* @return null
*
* @throws DOMException
*/
public Element createElement(String tagName) throws DOMException
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
return null;
}
/**
* Unimplemented. See org.w3c.dom.Document
*
* @return null
*/
public DocumentFragment createDocumentFragment()
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
return null;
}
/**
* Unimplemented. See org.w3c.dom.Document
*
* @param data Data for text node
*
* @return null
*/
public Text createTextNode(String data)
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
return null;
}
/**
* Unimplemented. See org.w3c.dom.Document
*
* @param data Data for comment
*
* @return null
*/
public Comment createComment(String data)
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
return null;
}
/**
* Unimplemented. See org.w3c.dom.Document
*
* @param data Data for CDATA section
*
* @return null
*
* @throws DOMException
*/
public CDATASection createCDATASection(String data) throws DOMException
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
return null;
}
/**
* Unimplemented. See org.w3c.dom.Document
*
* @param target Target for Processing instruction
* @param data Data for Processing instruction
*
* @return null
*
* @throws DOMException
*/
public ProcessingInstruction createProcessingInstruction(
String target, String data) throws DOMException
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
return null;
}
/**
* Unimplemented. See org.w3c.dom.Document
*
* @param name Attribute name
*
* @return null
*
* @throws DOMException
*/
public Attr createAttribute(String name) throws DOMException
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
return null;
}
/**
* Unimplemented. See org.w3c.dom.Document
*
* @param name Entity Reference name
*
* @return null
*
* @throws DOMException
*/
public EntityReference createEntityReference(String name)
throws DOMException
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
return null;
}
/**
* Unimplemented. See org.w3c.dom.Document
*
* @param importedNode The node to import.
* @param deep If true, recursively import the subtree under
* the specified node; if false, import only the node
* itself, as explained above. This has no effect on Attr
* , EntityReference, and Notation nodes.
*
* @return null
*
* @throws DOMException
*/
public Node importNode(Node importedNode, boolean deep) throws DOMException
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
return null;
}
/**
* Unimplemented. See org.w3c.dom.Document
*
* @param namespaceURI Namespace URI for the element
* @param qualifiedName Qualified name of the element
*
* @return null
*
* @throws DOMException
*/
public Element createElementNS(String namespaceURI, String qualifiedName)
throws DOMException
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
return null;
}
/**
* Unimplemented. See org.w3c.dom.Document
*
* @param namespaceURI Namespace URI of the attribute
* @param qualifiedName Qualified name of the attribute
*
* @return null
*
* @throws DOMException
*/
public Attr createAttributeNS(String namespaceURI, String qualifiedName)
throws DOMException
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
return null;
}
/**
* Unimplemented. See org.w3c.dom.Document
*
* @param elementId ID of the element to get
*
* @return null
*/
public Element getElementById(String elementId)
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
return null;
}
/**
* Set Node data
*
*
* @param data data to set for this node
*
* @throws DOMException
*/
public void setData(String data) throws DOMException
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
}
/**
* Unimplemented.
*
* @param offset Start offset of substring to extract.
* @param count The length of the substring to extract.
*
* @return null
*
* @throws DOMException
*/
public String substringData(int offset, int count) throws DOMException
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
return null;
}
/**
* Unimplemented.
*
* @param arg String data to append
*
* @throws DOMException
*/
public void appendData(String arg) throws DOMException
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
}
/**
* Unimplemented.
*
* @param offset Start offset of substring to insert.
* NEEDSDOC @param arg
*
* @throws DOMException
*/
public void insertData(int offset, String arg) throws DOMException
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
}
/**
* Unimplemented.
*
* @param offset Start offset of substring to delete.
* @param count The length of the substring to delete.
*
* @throws DOMException
*/
public void deleteData(int offset, int count) throws DOMException
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
}
/**
* Unimplemented.
*
* @param offset Start offset of substring to replace.
* @param count The length of the substring to replace.
* @param arg substring to replace with
*
* @throws DOMException
*/
public void replaceData(int offset, int count, String arg)
throws DOMException
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
}
/**
* Unimplemented.
*
* @param offset Offset into text to split
*
* @return null, unimplemented
*
* @throws DOMException
*/
public Text splitText(int offset) throws DOMException
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
return null;
}
/**
* NEEDSDOC Method adoptNode
*
*
* NEEDSDOC @param source
*
* NEEDSDOC (adoptNode) @return
*
* @throws DOMException
*/
public Node adoptNode(Node source) throws DOMException
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
return null;
}
/**
* Based on the Document * Object Model (DOM) Level 3 Core Specification of 07 April 2004.. *
* An attribute specifying, as part of the XML declaration, the encoding
* of this document. This is null when unspecified.
* @since DOM Level 3
*
* NEEDSDOC ($objectName$) @return
*/
public String getInputEncoding()
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
return null;
}
/**
*
Based on the Document * Object Model (DOM) Level 3 Core Specification of 07 April 2004.. *
* An attribute specifying, as part of the XML declaration, the encoding
* of this document. This is null when unspecified.
* @since DOM Level 3
*
* NEEDSDOC @param encoding
*/
public void setInputEncoding(String encoding)
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
}
/**
*
Based on the Document * Object Model (DOM) Level 3 Core Specification of 07 April 2004.. *
* An attribute specifying whether errors checking is enforced or not.
* When set to false, the implementation is free to not
* test every possible error case normally defined on DOM operations,
* and not raise any DOMException. In case of error, the
* behavior is undefined. This attribute is true by
* defaults.
* @since DOM Level 3
*
* NEEDSDOC ($objectName$) @return
*/
public boolean getStrictErrorChecking()
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
return false;
}
/**
*
Based on the Document * Object Model (DOM) Level 3 Core Specification of 07 April 2004.. *
* An attribute specifying whether errors checking is enforced or not.
* When set to false, the implementation is free to not
* test every possible error case normally defined on DOM operations,
* and not raise any DOMException. In case of error, the
* behavior is undefined. This attribute is true by
* defaults.
* @since DOM Level 3
*
* NEEDSDOC @param strictErrorChecking
*/
public void setStrictErrorChecking(boolean strictErrorChecking)
{
error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);
}
// RAMESH : Pending proper implementation of DOM Level 3
public Object setUserData(String key,
Object data,
UserDataHandler handler) {
return getOwnerDocument().setUserData( key, data, handler);
}
/**
* Retrieves the object associated to a key on a this node. The object
* must first have been set to this node by calling
* setUserData with the same key.
* @param key The key the object is associated to.
* @return Returns the DOMObject associated to the given key
* on this node, or null if there was none.
* @since DOM Level 3
*/
public Object getUserData(String key) {
return getOwnerDocument().getUserData( key);
}
/**
* This method returns a specialized object which implements the
* specialized APIs of the specified feature and version. The
* specialized object may also be obtained by using binding-specific
* casting methods but is not necessarily expected to, as discussed in Mixed DOM implementations.
* @param feature The name of the feature requested (case-insensitive).
* @param version This is the version number of the feature to test. If
* the version is null or the empty string, supporting
* any version of the feature will cause the method to return an
* object that supports at least one version of the feature.
* @return Returns an object which implements the specialized APIs of
* the specified feature and version, if any, or null if
* there is no object which implements interfaces associated with that
* feature. If the DOMObject returned by this method
* implements the Node interface, it must delegate to the
* primary core Node and not return results inconsistent
* with the primary core Node such as attributes,
* childNodes, etc.
* @since DOM Level 3
*/
public Object getFeature(String feature, String version) {
// we don't have any alternate node, either this node does the job
// or we don't have anything that does
return isSupported(feature, version) ? this : null;
}
/**
* Tests whether two nodes are equal.
*
This method tests for equality of nodes, not sameness (i.e.,
* whether the two nodes are references to the same object) which can be
* tested with Node.isSameNode. All nodes that are the same
* will also be equal, though the reverse may not be true.
*
Two nodes are equal if and only if the following conditions are
* satisfied: The two nodes are of the same type.The following string
* attributes are equal: nodeName, localName,
* namespaceURI, prefix, nodeValue
* , baseURI. This is: they are both null, or
* they have the same length and are character for character identical.
* The attributes NamedNodeMaps are equal.
* This is: they are both null, or they have the same
* length and for each node that exists in one map there is a node that
* exists in the other map and is equal, although not necessarily at the
* same index.The childNodes NodeLists are
* equal. This is: they are both null, or they have the
* same length and contain equal nodes at the same index. This is true
* for Attr nodes as for any other type of node. Note that
* normalization can affect equality; to avoid this, nodes should be
* normalized before being compared.
*
For two DocumentType nodes to be equal, the following
* conditions must also be satisfied: The following string attributes
* are equal: publicId, systemId,
* internalSubset.The entities
* NamedNodeMaps are equal.The notations
* NamedNodeMaps are equal.
*
On the other hand, the following do not affect equality: the
* ownerDocument attribute, the specified
* attribute for Attr nodes, the
* isWhitespaceInElementContent attribute for
* Text nodes, as well as any user data or event listeners
* registered on the nodes.
* @param arg The node to compare equality with.
* @param deep If true, recursively compare the subtrees; if
* false, compare only the nodes themselves (and its
* attributes, if it is an Element).
* @return If the nodes, and possibly subtrees are equal,
* true otherwise false.
* @since DOM Level 3
*/
public boolean isEqualNode(Node arg) {
if (arg == this) {
return true;
}
if (arg.getNodeType() != getNodeType()) {
return false;
}
// in theory nodeName can't be null but better be careful
// who knows what other implementations may be doing?...
if (getNodeName() == null) {
if (arg.getNodeName() != null) {
return false;
}
}
else if (!getNodeName().equals(arg.getNodeName())) {
return false;
}
if (getLocalName() == null) {
if (arg.getLocalName() != null) {
return false;
}
}
else if (!getLocalName().equals(arg.getLocalName())) {
return false;
}
if (getNamespaceURI() == null) {
if (arg.getNamespaceURI() != null) {
return false;
}
}
else if (!getNamespaceURI().equals(arg.getNamespaceURI())) {
return false;
}
if (getPrefix() == null) {
if (arg.getPrefix() != null) {
return false;
}
}
else if (!getPrefix().equals(arg.getPrefix())) {
return false;
}
if (getNodeValue() == null) {
if (arg.getNodeValue() != null) {
return false;
}
}
else if (!getNodeValue().equals(arg.getNodeValue())) {
return false;
}
/*
if (getBaseURI() == null) {
if (((NodeImpl) arg).getBaseURI() != null) {
return false;
}
}
else if (!getBaseURI().equals(((NodeImpl) arg).getBaseURI())) {
return false;
}
*/
return true;
}
/**
* DOM Level 3:
* Look up the namespace URI associated to the given prefix, starting from this node.
* Use lookupNamespaceURI(null) to lookup the default namespace
*
* @param namespaceURI
* @return th URI for the namespace
* @since DOM Level 3
*/
public String lookupNamespaceURI(String specifiedPrefix) {
short type = this.getNodeType();
switch (type) {
case Node.ELEMENT_NODE : {
String namespace = this.getNamespaceURI();
String prefix = this.getPrefix();
if (namespace !=null) {
// REVISIT: is it possible that prefix is empty string?
if (specifiedPrefix== null && prefix==specifiedPrefix) {
// looking for default namespace
return namespace;
} else if (prefix != null && prefix.equals(specifiedPrefix)) {
// non default namespace
return namespace;
}
}
if (this.hasAttributes()) {
NamedNodeMap map = this.getAttributes();
int length = map.getLength();
for (int i=0;itrue if the specified namespaceURI
* is the default namespace, false otherwise.
* @since DOM Level 3
*/
public boolean isDefaultNamespace(String namespaceURI){
/*
// REVISIT: remove casts when DOM L3 becomes REC.
short type = this.getNodeType();
switch (type) {
case Node.ELEMENT_NODE: {
String namespace = this.getNamespaceURI();
String prefix = this.getPrefix();
// REVISIT: is it possible that prefix is empty string?
if (prefix == null || prefix.length() == 0) {
if (namespaceURI == null) {
return (namespace == namespaceURI);
}
return namespaceURI.equals(namespace);
}
if (this.hasAttributes()) {
ElementImpl elem = (ElementImpl)this;
NodeImpl attr = (NodeImpl)elem.getAttributeNodeNS("http://www.w3.org/2000/xmlns/", "xmlns");
if (attr != null) {
String value = attr.getNodeValue();
if (namespaceURI == null) {
return (namespace == value);
}
return namespaceURI.equals(value);
}
}
NodeImpl ancestor = (NodeImpl)getElementAncestor(this);
if (ancestor != null) {
return ancestor.isDefaultNamespace(namespaceURI);
}
return false;
}
case Node.DOCUMENT_NODE:{
return((NodeImpl)((Document)this).getDocumentElement()).isDefaultNamespace(namespaceURI);
}
case Node.ENTITY_NODE :
case Node.NOTATION_NODE:
case Node.DOCUMENT_FRAGMENT_NODE:
case Node.DOCUMENT_TYPE_NODE:
// type is unknown
return false;
case Node.ATTRIBUTE_NODE:{
if (this.ownerNode.getNodeType() == Node.ELEMENT_NODE) {
return ownerNode.isDefaultNamespace(namespaceURI);
}
return false;
}
default:{
NodeImpl ancestor = (NodeImpl)getElementAncestor(this);
if (ancestor != null) {
return ancestor.isDefaultNamespace(namespaceURI);
}
return false;
}
}
*/
return false;
}
/**
*
* DOM Level 3:
* Look up the prefix associated to the given namespace URI, starting from this node.
*
* @param namespaceURI
* @return the prefix for the namespace
*/
public String lookupPrefix(String namespaceURI){
// REVISIT: When Namespaces 1.1 comes out this may not be true
// Prefix can't be bound to null namespace
if (namespaceURI == null) {
return null;
}
short type = this.getNodeType();
switch (type) {
/*
case Node.ELEMENT_NODE: {
String namespace = this.getNamespaceURI(); // to flip out children
return lookupNamespacePrefix(namespaceURI, (ElementImpl)this);
}
case Node.DOCUMENT_NODE:{
return((NodeImpl)((Document)this).getDocumentElement()).lookupPrefix(namespaceURI);
}
*/
case Node.ENTITY_NODE :
case Node.NOTATION_NODE:
case Node.DOCUMENT_FRAGMENT_NODE:
case Node.DOCUMENT_TYPE_NODE:
// type is unknown
return null;
case Node.ATTRIBUTE_NODE:{
if (this.getOwnerElement().getNodeType() == Node.ELEMENT_NODE) {
return getOwnerElement().lookupPrefix(namespaceURI);
}
return null;
}
default:{
/*
NodeImpl ancestor = (NodeImpl)getElementAncestor(this);
if (ancestor != null) {
return ancestor.lookupPrefix(namespaceURI);
}
*/
return null;
}
}
}
/**
* Returns whether this node is the same node as the given one.
*
This method provides a way to determine whether two
* Node references returned by the implementation reference
* the same object. When two Node references are references
* to the same object, even if through a proxy, the references may be
* used completely interchangably, such that all attributes have the
* same values and calling the same DOM method on either reference
* always has exactly the same effect.
* @param other The node to test against.
* @return Returns true if the nodes are the same,
* false otherwise.
* @since DOM Level 3
*/
public boolean isSameNode(Node other) {
// we do not use any wrapper so the answer is obvious
return this == other;
}
/**
* This attribute returns the text content of this node and its
* descendants. When it is defined to be null, setting it has no effect.
* When set, any possible children this node may have are removed and
* replaced by a single Text node containing the string
* this attribute is set to. On getting, no serialization is performed,
* the returned string does not contain any markup. No whitespace
* normalization is performed, the returned string does not contain the
* element content whitespaces . Similarly, on setting, no parsing is
* performed either, the input string is taken as pure textual content.
*
The string returned is made of the text content of this node
* depending on its type, as defined below:
*
*
* @exception DOMException
* NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
* @exception DOMException
* DOMSTRING_SIZE_ERR: Raised when it would return more characters than
* fit in a
*
* Node type
* Content
*
*
*
* ELEMENT_NODE, ENTITY_NODE, ENTITY_REFERENCE_NODE,
* DOCUMENT_FRAGMENT_NODE
* concatenation of the
* textContent
* attribute value of every child node, excluding COMMENT_NODE and
* PROCESSING_INSTRUCTION_NODE nodes
*
* ATTRIBUTE_NODE, TEXT_NODE,
* CDATA_SECTION_NODE, COMMENT_NODE, PROCESSING_INSTRUCTION_NODE
*
*
* nodeValue
*
* DOCUMENT_NODE, DOCUMENT_TYPE_NODE, NOTATION_NODE
*
* null
* DOMString variable on the implementation
* platform.
* @since DOM Level 3
*/
public void setTextContent(String textContent)
throws DOMException {
setNodeValue(textContent);
}
/**
* This attribute returns the text content of this node and its
* descendants. When it is defined to be null, setting it has no effect.
* When set, any possible children this node may have are removed and
* replaced by a single Text node containing the string
* this attribute is set to. On getting, no serialization is performed,
* the returned string does not contain any markup. No whitespace
* normalization is performed, the returned string does not contain the
* element content whitespaces . Similarly, on setting, no parsing is
* performed either, the input string is taken as pure textual content.
*
The string returned is made of the text content of this node
* depending on its type, as defined below:
*
*
* @exception DOMException
* NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
* @exception DOMException
* DOMSTRING_SIZE_ERR: Raised when it would return more characters than
* fit in a
*
* Node type
* Content
*
*
*
* ELEMENT_NODE, ENTITY_NODE, ENTITY_REFERENCE_NODE,
* DOCUMENT_FRAGMENT_NODE
* concatenation of the
* textContent
* attribute value of every child node, excluding COMMENT_NODE and
* PROCESSING_INSTRUCTION_NODE nodes
*
* ATTRIBUTE_NODE, TEXT_NODE,
* CDATA_SECTION_NODE, COMMENT_NODE, PROCESSING_INSTRUCTION_NODE
*
*
* nodeValue
*
* DOCUMENT_NODE, DOCUMENT_TYPE_NODE, NOTATION_NODE
*
* null
* DOMString variable on the implementation
* platform.
* @since DOM Level 3
*/
public String getTextContent() throws DOMException {
return getNodeValue(); // overriden in some subclasses
}
/**
* Compares a node with this node with regard to their position in the
* document.
* @param other The node to compare against this node.
* @return Returns how the given node is positioned relatively to this
* node.
* @since DOM Level 3
*/
public short compareDocumentPosition(Node other) throws DOMException {
return 0;
}
/**
* The absolute base URI of this node or null if undefined.
* This value is computed according to . However, when the
* Document supports the feature "HTML" , the base URI is
* computed using first the value of the href attribute of the HTML BASE
* element if any, and the value of the documentURI
* attribute from the Document interface otherwise.
*
When the node is an Element, a Document
* or a a ProcessingInstruction, this attribute represents
* the properties [base URI] defined in . When the node is a
* Notation, an Entity, or an
* EntityReference, this attribute represents the
* properties [declaration base URI] in the . How will this be affected
* by resolution of relative namespace URIs issue?It's not.Should this
* only be on Document, Element, ProcessingInstruction, Entity, and
* Notation nodes, according to the infoset? If not, what is it equal to
* on other nodes? Null? An empty string? I think it should be the
* parent's.No.Should this be read-only and computed or and actual
* read-write attribute?Read-only and computed (F2F 19 Jun 2000 and
* teleconference 30 May 2001).If the base HTML element is not yet
* attached to a document, does the insert change the Document.baseURI?
* Yes. (F2F 26 Sep 2001)
* @since DOM Level 3
*/
public String getBaseURI() {
return null;
}
/**
* DOM Level 3
* Renaming node
*/
public Node renameNode(Node n,
String namespaceURI,
String name)
throws DOMException{
return n;
}
/**
* DOM Level 3
* Normalize document.
*/
public void normalizeDocument(){
}
/**
* The configuration used when Document.normalizeDocument is
* invoked.
* @since DOM Level 3
*/
public DOMConfiguration getDomConfig(){
return null;
}
/** DOM Level 3 feature: documentURI */
protected String fDocumentURI;
/**
* DOM Level 3
*/
public void setDocumentURI(String documentURI){
fDocumentURI= documentURI;
}
/**
* DOM Level 3
* The location of the document or null if undefined.
*
Beware that when the Document supports the feature
* "HTML" , the href attribute of the HTML BASE element takes precedence
* over this attribute.
* @since DOM Level 3
*/
public String getDocumentURI(){
return fDocumentURI;
}
/** DOM Level 3 feature: Document actualEncoding */
protected String actualEncoding;
/**
* DOM Level 3
* An attribute specifying the actual encoding of this document. This is
* null otherwise.
*
This attribute represents the property [character encoding scheme]
* defined in .
* @since DOM Level 3
*/
public String getActualEncoding() {
return actualEncoding;
}
/**
* DOM Level 3
* An attribute specifying the actual encoding of this document. This is
* null otherwise.
*
This attribute represents the property [character encoding scheme]
* defined in .
* @since DOM Level 3
*/
public void setActualEncoding(String value) {
actualEncoding = value;
}
/**
* DOM Level 3
*/
public Text replaceWholeText(String content)
throws DOMException{
/*
if (needsSyncData()) {
synchronizeData();
}
// make sure we can make the replacement
if (!canModify(nextSibling)) {
throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR,
DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "NO_MODIFICATION_ALLOWED_ERR", null));
}
Node parent = this.getParentNode();
if (content == null || content.length() == 0) {
// remove current node
if (parent !=null) { // check if node in the tree
parent.removeChild(this);
return null;
}
}
Text currentNode = null;
if (isReadOnly()){
Text newNode = this.ownerDocument().createTextNode(content);
if (parent !=null) { // check if node in the tree
parent.insertBefore(newNode, this);
parent.removeChild(this);
currentNode = newNode;
} else {
return newNode;
}
} else {
this.setData(content);
currentNode = this;
}
Node sibling = currentNode.getNextSibling();
while ( sibling !=null) {
parent.removeChild(sibling);
sibling = currentNode.getNextSibling();
}
return currentNode;
*/
return null; //Pending
}
/**
* DOM Level 3
* Returns all text of Text nodes logically-adjacent text
* nodes to this node, concatenated in document order.
* @since DOM Level 3
*/
public String getWholeText(){
/*
if (needsSyncData()) {
synchronizeData();
}
if (nextSibling == null) {
return data;
}
StringBuffer buffer = new StringBuffer();
if (data != null && data.length() != 0) {
buffer.append(data);
}
getWholeText(nextSibling, buffer);
return buffer.toString();
*/
return null; // PENDING
}
/**
* DOM Level 3
* Returns whether this text node contains whitespace in element content,
* often abusively called "ignorable whitespace".
*/
public boolean isWhitespaceInElementContent(){
return false;
}
/**
* NON-DOM: set the type of this attribute to be ID type.
*
* @param id
*/
public void setIdAttribute(boolean id){
//PENDING
}
/**
* DOM Level 3: register the given attribute node as an ID attribute
*/
public void setIdAttribute(String name, boolean makeId) {
//PENDING
}
/**
* DOM Level 3: register the given attribute node as an ID attribute
*/
public void setIdAttributeNode(Attr at, boolean makeId) {
//PENDING
}
/**
* DOM Level 3: register the given attribute node as an ID attribute
*/
public void setIdAttributeNS(String namespaceURI, String localName,
boolean makeId) {
//PENDING
}
/**
* Method getSchemaTypeInfo.
* @return TypeInfo
*/
public TypeInfo getSchemaTypeInfo(){
return null; //PENDING
}
public boolean isId() {
return false; //PENDING
}
private String xmlEncoding;
public String getXmlEncoding ( ) {
return xmlEncoding;
}
public void setXmlEncoding ( String xmlEncoding ) {
this.xmlEncoding = xmlEncoding;
}
private boolean xmlStandalone;
public boolean getXmlStandalone() {
return xmlStandalone;
}
public void setXmlStandalone(boolean xmlStandalone) throws DOMException {
this.xmlStandalone = xmlStandalone;
}
private String xmlVersion;
public String getXmlVersion() {
return xmlVersion;
}
public void setXmlVersion(String xmlVersion) throws DOMException {
this.xmlVersion = xmlVersion;
}
}