DocumentFragment is a "lightweight" or "minimal"
* Document object.
*
* It is very common to want to be able to
* extract a portion of a document's tree or to create a new fragment of a
* document. Imagine implementing a user command like cut or rearranging a
* document by moving fragments around. It is desirable to have an object
* which can hold such fragments and it is quite natural to use a Node for
* this purpose. While it is true that a Document object could
* fulfil this role, a Document object can potentially be a
* heavyweight object, depending on the underlying implementation. What is
* really needed for this is a very lightweight object.
* DocumentFragment is such an object.
* Furthermore, various operations -- such as inserting nodes as children
* of another Node -- may take DocumentFragment
* objects as arguments; this results in all the child nodes of the
* DocumentFragment being moved to the child list of this node.
*
The children of a DocumentFragment node are zero or more
* nodes representing the tops of any sub-trees defining the structure of the
* document. DocumentFragment nodes do not need to be
* well-formed XML documents (although they do need to follow the rules
* imposed upon well-formed XML parsed entities, which can have multiple top
* nodes). For example, a DocumentFragment might have only one
* child and that child node could be a Text node. Such a
* structure model represents neither an HTML document nor a well-formed XML
* document.
*
When a DocumentFragment is inserted into a
* Document (or indeed any other Node that may take
* children) the children of the DocumentFragment and not the
* DocumentFragment itself are inserted into the
* Node. This makes the DocumentFragment very
* useful when the user wishes to create nodes that are siblings; the
* DocumentFragment acts as the parent of these nodes so that the
* user can use the standard methods from the Node interface,
* such as insertBefore() and appendChild().
*/
class CDOM_EXPORT DOM_DocumentFragment: public DOM_Node {
public:
/** @name Constructors and assignment operators */
//@{
/**
* Default constructor for DOM_DocumentFragment. The resulting object does not
* refer to an actual Document Fragment 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 Document Fragment node.
*
* New document fragment nodes are created by DOM_Document::createDocumentFragment().
*
*/
DOM_DocumentFragment();
/**
* Copy constructor. Creates a new DOM_DocumentFragment that refers to the
* same underlying node as the original. See also DOM_Node::clone(),
* which will copy the actual Document fragment node, rather than just creating a new
* reference to the original node.
*
* @param other The object to be copied
*/
DOM_DocumentFragment(const DOM_DocumentFragment &other);
/**
* Assignment operator
*
* @param other The object to be copied
*/
DOM_DocumentFragment & operator = (const DOM_DocumentFragment &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_DocumentFragment & operator = (const DOM_NullPtr *val);
//@}
/** @name Destructor */
//@{
/**
* Destructor. The object being destroyed is the reference
* object, not the underlying Comment node itself.
*
*/
~DOM_DocumentFragment();
//@}
protected:
DOM_DocumentFragment(DocumentFragmentImpl *);
friend class DOM_Document;
friend class RangeImpl;
};
XERCES_CPP_NAMESPACE_END
#endif