Text interface represents the textual content (termed
* character data in XML) of an Element or Attr.
* If there is no markup inside an element's content, the text is contained
* in a single object implementing the Text interface that is
* the only child of the element. If there is markup, it is parsed into a
* list of elements and Text nodes that form the list of
* children of the element.
* When a document is first made available via the DOM, there is only one
* Text node for each block of text. Users may create adjacent
* 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, so they
* will not (in general) persist between DOM editing sessions. The
* normalize() method on Element merges any such
* adjacent Text objects into a single node for each block of
* text; this is recommended before employing operations that depend on a
* particular document structure, such as navigation with
* XPointers.
*/
class CDOM_EXPORT DOM_Text: public DOM_CharacterData {
public:
/** @name Constructors and assignment operator */
//@{
/**
* Default constructor for DOM_Text. The resulting object does not
* refer to an actual Text node; it will compare == to 0, and is similar
* to a null object reference variable in Java. It may subsequently be
* assigned to refer to an actual comment node.
*
*/
DOM_Text();
/**
* Copy constructor. Creates a new DOM_Text that refers to the
* same underlying node as the original. See also DOM_Node::clone(),
* which will copy the actual Text node, rather than just creating a new
* reference to the original node.
*
* @param other The object to be copied.
*/
DOM_Text(const DOM_Text &other);
/**
* Assignment operator.
*
* @param other The object to be copied.
*/
DOM_Text & operator = (const DOM_Text &other);
/**
* Assignment operator. This overloaded variant is provided for
* the sole purpose of setting a DOM_Node reference variable to
* zero. Nulling out a reference variable in this way will decrement
* the reference count on the underlying Node object that the variable
* formerly referenced. This effect is normally obtained when reference
* variable goes out of scope, but zeroing them can be useful for
* global instances, or for local instances that will remain in scope
* for an extended time, when the storage belonging to the underlying
* node needs to be reclaimed.
*
* @param val Only a value of 0, or null, is allowed.
*/
DOM_Text & operator = (const DOM_NullPtr *val);
//@}
/** @name Destructor. */
//@{
/**
* Destructor for DOM_Text. The object being destroyed is the reference
* object, not the underlying Comment node itself.
*
*/
~DOM_Text();
//@}
/** @name Functions to modify the Text node. */
//@{
/**
* Breaks this node into two nodes at the specified
* offset, keeping both in the tree as siblings.
*
* This node then only
* contains all the content up to the offset point. And a new
* node of the same nodeType, which is inserted as the next sibling of this
* node, contains all the content at and after the offset
* point. When the offset is equal to the lenght of this node,
* the new node has no data.
* @param offset The offset at which to split, starting from 0.
* @return The new Text node.
* @exception DOMException
* INDEX_SIZE_ERR: Raised if the specified offset is negative or greater
* than the number of characters in data.
*
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
*/
DOM_Text splitText(unsigned int offset);
//@}
/** @name Non-standard (not defined by the DOM specification) functions. */
//@{
/**
*
* Return true if this node contains ignorable whitespaces only.
* @return True if this node contains ignorable whitespaces only.
*/
bool isIgnorableWhitespace();
//@}
protected:
DOM_Text(TextImpl *);
friend class DOM_Document;
friend class RangeImpl;
};
XERCES_CPP_NAMESPACE_END
#endif