The DefaultText.java Java example source code
/*
* reserved comment block
* DO NOT REMOVE OR ALTER!
*/
/*
* Copyright 2001-2004 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.sun.org.apache.xerces.internal.impl.xs.opti;
import org.w3c.dom.Text;
import org.w3c.dom.DOMException;
/*
* @author Neil Graham, IBM
*/
/**
* The <code>Text interface inherits from CharacterData
* and represents the textual content (termed character data in XML) of an
* <code>Element or Attr
. If there is no markup inside
* an element's content, the text is contained in a single object
* implementing the <code>Text interface that is the only child of
* the element. If there is markup, it is parsed into the information items
* (elements, comments, etc.) and <code>Text nodes that form the list
* of children of the element.
* <p>When a document is first made available via the DOM, there is only one
* <code>Text node for each block of text. Users may create adjacent
* <code>Text nodes that represent the contents of a given element
* without any intervening markup, but should be aware that there is no way
* to represent the separations between these nodes in XML or HTML, so they
* will not (in general) persist between DOM editing sessions. The
* <code>normalize() method on Node
merges any such
* adjacent <code>Text objects into a single node for each block of
* text.
* <p>See also the Document Object Model (DOM) Level 2 Core Specification.
*
* This is an empty implementation.
*
* @xerces.internal
*/
public class DefaultText extends NodeImpl implements Text {
// CharacterData methods
/**
* The character data of the node that implements this interface. The DOM
* implementation may not put arbitrary limits on the amount of data
* that may be stored in a <code>CharacterData node. However,
* implementation limits may mean that the entirety of a node's data may
* not fit into a single <code>DOMString. In such cases, the user
* may call <code>substringData to retrieve the data in
* appropriately sized pieces.
* @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 <code>DOMString variable on the implementation
* platform.
*/
public String getData()
throws DOMException {
return null;
}
/**
* The character data of the node that implements this interface. The DOM
* implementation may not put arbitrary limits on the amount of data
* that may be stored in a <code>CharacterData node. However,
* implementation limits may mean that the entirety of a node's data may
* not fit into a single <code>DOMString. In such cases, the user
* may call <code>substringData to retrieve the data in
* appropriately sized pieces.
* @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 <code>DOMString variable on the implementation
* platform.
*/
public void setData(String data)
throws DOMException {
throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Method not supported");
}
/**
* The number of 16-bit units that are available through <code>data
* and the <code>substringData method below. This may have the
* value zero, i.e., <code>CharacterData nodes may be empty.
*/
public int getLength() {
return 0;
}
/**
* Extracts a range of data from the node.
* @param offset Start offset of substring to extract.
* @param count The number of 16-bit units to extract.
* @return The specified substring. If the sum of <code>offset and
* <code>count exceeds the length
, then all 16-bit
* units to the end of the data are returned.
* @exception DOMException
* INDEX_SIZE_ERR: Raised if the specified <code>offset is
* negative or greater than the number of 16-bit units in
* <code>data, or if the specified count
is
* negative.
* <br>DOMSTRING_SIZE_ERR: Raised if the specified range of text does
* not fit into a <code>DOMString.
*/
public String substringData(int offset,
int count)
throws DOMException {
throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Method not supported");
}
/**
* Append the string to the end of the character data of the node. Upon
* success, <code>data provides access to the concatenation of
* <code>data and the DOMString
specified.
* @param arg The <code>DOMString to append.
* @exception DOMException
* NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
*/
public void appendData(String arg)
throws DOMException {
throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Method not supported");
}
/**
* Insert a string at the specified 16-bit unit offset.
* @param offset The character offset at which to insert.
* @param arg The <code>DOMString to insert.
* @exception DOMException
* INDEX_SIZE_ERR: Raised if the specified <code>offset is
* negative or greater than the number of 16-bit units in
* <code>data.
* <br>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
*/
public void insertData(int offset,
String arg)
throws DOMException {
throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Method not supported");
}
/**
* Remove a range of 16-bit units from the node. Upon success,
* <code>data and length
reflect the change.
* @param offset The offset from which to start removing.
* @param count The number of 16-bit units to delete. If the sum of
* <code>offset and count
exceeds
* <code>length then all 16-bit units from offset
* to the end of the data are deleted.
* @exception DOMException
* INDEX_SIZE_ERR: Raised if the specified <code>offset is
* negative or greater than the number of 16-bit units in
* <code>data, or if the specified count
is
* negative.
* <br>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
*/
public void deleteData(int offset,
int count)
throws DOMException {
throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Method not supported");
}
/**
* Replace the characters starting at the specified 16-bit unit offset
* with the specified string.
* @param offset The offset from which to start replacing.
* @param count The number of 16-bit units to replace. If the sum of
* <code>offset and count
exceeds
* <code>length, then all 16-bit units to the end of the data
* are replaced; (i.e., the effect is the same as a <code>remove
* method call with the same range, followed by an <code>append
* method invocation).
* @param arg The <code>DOMString with which the range must be
* replaced.
* @exception DOMException
* INDEX_SIZE_ERR: Raised if the specified <code>offset is
* negative or greater than the number of 16-bit units in
* <code>data, or if the specified count
is
* negative.
* <br>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
*/
public void replaceData(int offset,
int count,
String arg)
throws DOMException {
throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Method not supported");
}
// Text node methods
/**
* Breaks this node into two nodes at the specified <code>offset,
* keeping both in the tree as siblings. After being split, this node
* will contain all the content up to the <code>offset point. A
* new node of the same type, which contains all the content at and
* after the <code>offset point, is returned. If the original
* node had a parent node, the new node is inserted as the next sibling
* of the original node. When the <code>offset is equal to the
* length of this node, the new node has no data.
* @param offset The 16-bit unit offset at which to split, starting from
* <code>0.
* @return The new node, of the same type as this node.
* @exception DOMException
* INDEX_SIZE_ERR: Raised if the specified offset is negative or greater
* than the number of 16-bit units in <code>data.
* <br>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
*/
public Text splitText(int offset)
throws DOMException {
throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Method not supported");
}
/** DOM Level 3 CR */
public boolean isElementContentWhitespace(){
throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Method not supported");
}
public String getWholeText(){
throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Method not supported");
}
public Text replaceWholeText(String content) throws DOMException {
throw new DOMException(DOMException.NOT_SUPPORTED_ERR, "Method not supported");
}
}
Other Java examples (source code examples)
Here is a short list of links related to this Java DefaultText.java source code file: