BContent.h

Go to the documentation of this file.

#ifndef _B_XML_CONTENT_H
#define _B_XML_CONTENT_H

#include <xml/BXMLDefs.h>
#include <xml/BStringMap.h>

#include <String.h>

namespace B {
namespace XML {


// Forward References
// =====================================================================
class BXMLObject;
class BNamespace;
class BContent;
class BNamed;
class BElement;
class BDocument;
class BValued;
class BAttribute;
class BText;
class BCData;
class BComment;
class BNamedSet;
class BDocumentType;
class BProcessingInstruction;
class BDocumentTypeDefinition;
class BDocumentTypeDefinition;
class BElementDecl;
class BAttributeDecl;
class BEntityDecl;
class BXMLObjectFactory;
class BEntityStore;


// Some Sets of Pointers
// =====================================================================
// XXX should be fixed to be standard names
typedef _Pointer_Set_<BElement *>       ElementSet;
typedef _Pointer_Set_<BXMLObject *>     XMLObjectSet;           
typedef _Pointer_Set_<BXMLObject *>     BXMLObjectSet;
typedef _Pointer_Set_<BString *>        _StringSet_;


// Generic Type Coded XML Object
// =====================================================================
// Some xml objects (specifically BAttribute) don't have much in common
// functionally, but they all need a common base class.
class BXMLObject
{
public:
                            BXMLObject(uint32 type);
    virtual                 ~BXMLObject();
    
                            // Type Code
    uint32                  Type() const;
    
private:
    uint32                  _type;
};


// XML Content
// =====================================================================
// Base class of the classes that make up the document structure.
class BContent : public BXMLObject
{
public:
                            // All elements have parents except for the
                            // root element, where this returns null
    BElement                * Parent();
    const BElement          * Parent() const;
    
                            // Each node has a pointer to the document it's
                            // in (if it's in a document).  
    BDocument               * Document();
    const BDocument         * Document() const;
    
                            // The next sibling in document order.
                            // Mask looks until the next one that matches mask
                            // Element is a convience wrapper for NextSibMask(ELEMENT);
    BContent                * NextSibling();
    const BContent          * NextSibling() const;
    BContent                * NextSibling(uint32 typeMask);
    const BContent          * NextSibling(uint32 typeMask) const;
    BContent                * PreviousSibling();
    const BContent          * PreviousSibling() const;
    BContent                * PreviousSibling(uint32 typeMask);
    const BContent          * PreviousSibling(uint32 typeMask) const;
    
    BElement                * NextSiblingElement();
    const BElement          * NextSiblingElement() const;
    BElement                * PreviousSiblingElement();
    const BElement          * PreviousSiblingElement() const;
    
    virtual BContent        * Clone() const;
    
protected:
    
                            // You get a copy that is not connected to the document
                            // hierarchy
    explicit                BContent(const BContent & copy);
    
                            // Never create a plain BContent
                            BContent(uint32 type);
    
    virtual                 ~BContent();
    
private:
                            // Always need a type
                            BContent();
    
    bool                    check_content_for_connections();
    status_t                set_parent(BElement * parent);
    status_t                set_next_sibling(BContent * sibling);
    status_t                set_prev_sibling(BContent * sibling);
    status_t                set_document(BDocument * document);
    
    BElement                * _parent;
    BContent                * _nextSibling;
    BContent                * _prevSibling;
    BDocument               * _document;
    
    friend class BElement;      // BElement manages its list of elements
    friend class BDocument;     // BDocument manages its list of elements
};


// XML Named
// =====================================================================
// Simple mechanism for giving elements and attributes a name
// There is a corresponding BNamedSet that allows access to
// named things.
class BNamed
{
public:
    const char          * Name() const;
    
    virtual             ~BNamed();

protected:
    explicit            BNamed(const BNamed & copy);
    
                        BNamed(const char * name);
                        BNamed(const BString & name);
                        BNamed(BString & name, bool adopt = false);
    
                        // protected, because not all named things have namespaces
    BNamespace          * Namespace();
    const BNamespace    * Namespace() const;
    
    virtual void        SetName(const char * name);
    virtual status_t    SetNamespace(BNamespace * space);
    
private:
    BString             _name;
    BNamespace          * _namespace;
    
    friend class BNamedSet; // BNamedSet uses the protected Namespace() function
};


// XML Namespace
// =====================================================================
// This gets attached to an element or document, and pointed to by
// BNamed objects that are in that namespace
// The BNamed base class is the name of the prefix, because that's
// what we look up by
class BNamespace : public BNamed
{
public:
                    BNamespace(const BNamespace & copy);
                    BNamespace(const char * prefix, const char * value);
                    BNamespace(const BString & prefix, const BString & value);
                    BNamespace(BString & prefix, BString & value, bool adopt);
    
    virtual         ~BNamespace();
    
    const char *    Value() const;
    
                                    // Claims ownership
    virtual void                    SetDTD(BDocumentTypeDefinition * dtd);
    
    const BDocumentTypeDefinition   * GetDTD() const;
    BDocumentTypeDefinition         * GetDTD();
    
private:
                                BNamespace();
    
    BString                     _value;
    BDocumentTypeDefinition     * _dtd;
    
    friend class BNamedSet;
};


// Set of things with names
// =====================================================================
// Provides a set of BXMLNamed objects.  Used to keep track of attributes
// and some of the DTD declarations.  If you go through in index order,
// you get list sorted by name.
class BNamedSet
{
public:
                            BNamedSet();
    virtual                 ~BNamedSet();
    
    virtual status_t        Add(BNamed * named);
    virtual void            Remove(BNamed * named);
    virtual void            Remove(int32 index);
    virtual BNamed          * Find(const char * name);
    virtual const BNamed    * Find(const char * name) const;
    
    int32                   CountItems() const;
    BNamed                  * ItemAt(int32 index);
    const BNamed            * ItemAt(int32 index) const;
    
    virtual void            MakeEmpty(bool deleteData);
    
private:
    _Pointer_Set_<BNamed *> _data;
}; 


// XML Element
// =====================================================================
// BElement maps directly to the element construction in an XML document.
// Only BElement know about their children, and the only way to add an
// element to ta document is to add it to an element, even though it is
// actually stored as a linked list.
// All the add functions take ownership -- don't try to delete things you add
class BElement : public BContent, public BNamed
{
public:
    
    // --- Constructor and Destructor  ----------------------
                            BElement(const char * name);
                            BElement(const BString & name);
                            BElement(BString & name, bool adopt = false);
                            BElement(const BElement & copy);
    virtual                 ~BElement();
    
    virtual BContent        * Clone() const;
    BElement                & operator=(const BElement & copy);
    
    // --- Namespaces ---------------------------------------
                            // Add this element to the namespace space
    virtual status_t        SetNamespace(BNamespace * space);
    using                   BNamed::Namespace;
    
    virtual status_t        AddNamespace(BNamespace * space);
    
    int32                   CountNamespaces() const;
    BNamespace              * NamespaceAt(int32 index);
    const BNamespace        * NamespaceAt(int32 index) const;
    
    BNamespace              * FindNamespaceByPrefix(const char * prefix);
    const BNamespace        * FindNamespaceByPrefix(const char * prefix) const;
    BNamespace              * FindNamespaceByValue(const char * value);
    const BNamespace        * FindNamespaceByValue(const char * value) const;
    
                            // Find the element that the namespace is declared in.
                            // NULL if we can't find it.  The element will be either
                            // this element or one of its parents
    BElement                * FindNamespaceDecl(const BNamespace * space);
    const BElement          * FindNamespaceDecl(const BNamespace * space) const;
    
    // --- Getting Children ---------------------------------
                            // Access to the first and last children for iteration
                            // iteration over all of the children of any type.
                            // With a mask, it will find the first that fits it
    BContent                * FirstChild();
    const BContent          * FirstChild() const;
    BContent                * FirstChild(uint32 typeMask);
    const BContent          * FirstChild(uint32 typeMask) const;
    BContent                * LastChild();
    const BContent          * LastChild() const;
    BContent                * LastChild(uint32 typeMask);
    const BContent          * LastChild(uint32 typeMask) const;
    
                            // Find the index of the first element named
                            // <name> at or after index <atOrAfter>
    status_t                FindElementNamed(const char * name, BElement ** element);
    
    // --- Adding Children ----------------------------------
                            // Make it the first one, take ownership
    virtual status_t        AddChildFirst(BContent * content);
    
                            // Make it the last one, take ownership
    virtual status_t        AddChildLast(BContent * content);
    
                            // Put it before <before>, take ownership
    virtual status_t        AddChildBefore(BContent * content, BContent * before);
    
                            // Put it after <after>, take ownership
    virtual status_t        AddChildAfter(BContent * content, BContent * after);
    
    // --- Removing Children --------------------------------
                            // Does not delete it
    virtual status_t        RemoveChild(BContent * content);
    
    // --- Add Attributes -----------------------------------
    // The only way to find attributes is through their element.  Because they are
    // attached through a BXMLNamedSet, not through the BXMLNode linked list mechanism.
    
    // replace says what to do if it's already there:
    //     false: return an error if it already exists
    //     true:  replace it and return B_OK
    
                            // The other add attributes call this one
    virtual status_t        AddAttribute(BAttribute * attribute, bool replace = false);
    
    virtual status_t        AddAttribute(const char * name, const char * val, bool replace = false);
    virtual status_t        AddAttribute(const char * name, const BString & val, bool replace = false);

#if !_SMALL_XML_FOOTPRINT_
    virtual status_t        AddAttribute(const char * name, BRect val, bool replace = false);
    virtual status_t        AddAttribute(const char * name, BPoint val, bool replace = false);
    virtual status_t        AddAttribute(const char * name, int8 val, bool replace = false);
    virtual status_t        AddAttribute(const char * name, int16 val, bool replace = false);
    virtual status_t        AddAttribute(const char * name, int32 val, bool replace = false);
    virtual status_t        AddAttribute(const char * name, int64 val, bool replace = false);
    virtual status_t        AddAttribute(const char * name, uint8 val, bool replace = false);
    virtual status_t        AddAttribute(const char * name, uint16 val, bool replace = false);
    virtual status_t        AddAttribute(const char * name, uint32 val, bool replace = false);
    virtual status_t        AddAttribute(const char * name, uint64 val, bool replace = false);
    virtual status_t        AddAttribute(const char * name, bool val, bool replace = false);
    virtual status_t        AddAttribute(const char * name, float val, bool replace = false);
    virtual status_t        AddAttribute(const char * name, double val, bool replace = false);
                            // Will always use #xxxxxx format
    virtual status_t        AddAttributeRGBColor(const char * name, rgb_color val, bool replace = false);
                            // Will use HTML 4 colors if possible, else will use #xxxxxx format
    virtual status_t        AddAttributeHTMLColor(const char * name, rgb_color val, bool replace = false);
                            // If it's in the same document, will give an XPath to it
    virtual status_t        AddAttributeXPath(const char * name, BContent * which, bool replace = false);
#endif
    
    
    // --- Find Attributes ----------------------------------
    int32                   CountAttributes() const;
    BAttribute              * AttributeAt(int32 index) const;
    
                            // Is there an attribute that exactly matches attribute, but may or
                            // may not actually be the same object.
    bool                    FindAttribute(const BAttribute * attribute) const;
    
    // Find by name
    status_t                FindAttribute(const char * name, BAttribute ** attribute);
    status_t                FindAttribute(const char * name, const BAttribute ** attribute) const;
    status_t                FindAttribute(const char * name, const char ** val) const;
    status_t                FindAttribute(const char * name, BString * val) const;
    
#if !_SMALL_XML_FOOTPRINT_
    status_t                FindAttribute(const char * name, BRect * val) const;
    status_t                FindAttribute(const char * name, BPoint * val) const;
    status_t                FindAttribute(const char * name, int8 * val) const;
    status_t                FindAttribute(const char * name, int16 * val) const;
    status_t                FindAttribute(const char * name, int32 * val) const;
    status_t                FindAttribute(const char * name, int64 * val) const;
    status_t                FindAttribute(const char * name, uint8 * val) const;
    status_t                FindAttribute(const char * name, uint16 * val) const;
    status_t                FindAttribute(const char * name, uint32 * val) const;
    status_t                FindAttribute(const char * name, uint64 * val) const;
    status_t                FindAttribute(const char * name, bool * val) const;
    status_t                FindAttribute(const char * name, float * val) const;
    status_t                FindAttribute(const char * name, double * val) const;
    status_t                FindAttribute(const char * name, rgb_color * val) const;
                            // Will try to find a pointer to a BXMLNode at that XPath
    status_t                FindAttributeXPath(const char * name, BContent ** which);
#endif
    
    // These take a default argument, if it doesn't find the attribute, it gives
    // you the default and returns false.  If it does find it it gives it to you
    // and returns true.  Use these if you don't want to do error checking, and you
    // have a default value that you can use without a problem.
    //
    // Replaces the code:
    // int32 val;
    // if (element->FindAttribute("name", &val) != B_OK)
    //      val = 5;
    //
    // With:
    // element->FindAttribute("name", &val, 5);
    //

    bool                    FindAttribute(const char * name, const char ** val, const char * def) const;
    bool                    FindAttribute(const char * name, BString * val, const char * def) const;

#if !_SMALL_XML_FOOTPRINT_
    bool                    FindAttribute(const char * name, BRect * val, BRect def) const;
    bool                    FindAttribute(const char * name, BPoint * val, BPoint def) const;
    bool                    FindAttribute(const char * name, int8 * val, int8 def) const;
    bool                    FindAttribute(const char * name, int16 * val, int16 def) const;
    bool                    FindAttribute(const char * name, int32 * val, int32 def) const;
    bool                    FindAttribute(const char * name, int64 * val, int64 def) const;
    bool                    FindAttribute(const char * name, uint8 * val, uint8 def) const;
    bool                    FindAttribute(const char * name, uint16 * val, uint16 def) const;
    bool                    FindAttribute(const char * name, uint32 * val, uint32 def) const;
    bool                    FindAttribute(const char * name, uint64 * val, uint64 def) const;
    bool                    FindAttribute(const char * name, bool * val, bool def) const;
    bool                    FindAttribute(const char * name, float * val, float def) const;
    bool                    FindAttribute(const char * name, double * val, double def) const;
    bool                    FindAttribute(const char * name, rgb_color * val, rgb_color def) const;
                            // Will try to find a pointer to a BXMLNode at that XPath
                            // The default in this function isn't all that useful
    bool                    FindAttributeXPath(const char * name, BContent ** which, BContent * def);
#endif  
    
    // --- Remove Attributes --------------------------------
                            // Does not delete <attribute>
    virtual status_t        RemoveAttribute(BAttribute * attribute);
                            // Deletes the internally stored BAttribute
    virtual status_t        RemoveAttribute(const char * name);
    
    // --- Some Interesting Functions -----------------------
                            // Put this element into some normalized form.  TBD.
                            // For example, coalesce adjacent text or CData nodes
    // virtual void         Normalize();
    
    
    // --- Value of the Element... --------------------------
    
    // If the data inside this element can be coalesced by removing comments and/or
    // processing instructions, and joining all text and CData, then these functions
    // can get the values of the result of that coalescing.  If not, return an error.
    // Could also possibly put some convience methods into here to make
    // it do some fun stuff with attributes elements.  
    // For example, to get a rect, look at the top, left, bottom, right attributes,
    // if they all exist and can be floating point numbers, then this function would
    // work.  More thought needed here
    //
    // This makes the following constructs simple to access, where they would be a
    // pain; but it's a fairly common piece of XML.
    //      <Element>42</Element>   gives: "42"
    //      <Element>Whoah <!-- Hey Dude -->Momma!</Element>    gives: "Whoah Momma!"
    //      <Element>Whoah<!-- Hey Dude -->Momma!</Element>    gives: "WhoahMomma!"
    
    status_t                GetData(BString * data) const;
    
#if 0 && !_SMALL_XML_FOOTPRINT_
    status_t                GetData(BRect * data);
    status_t                GetData(BPoint * data);
    status_t                GetData(int8 * data);
    status_t                GetData(int16 * data);
    status_t                GetData(int32 * data);
    status_t                GetData(int64 * data);
    status_t                GetData(uint8 * data);
    status_t                GetData(uint16 * data);
    status_t                GetData(uint32 * data);
    status_t                GetData(uint64 * data);
    status_t                GetData(bool * data);
    status_t                GetData(float * data);
    status_t                GetData(double * data);
    status_t                GetData(rgb_color * data);
    status_t                GetDataXPath(BContent * pathTo);
    
    // Similar idea as before, except here we set it.  This just fails if there
    // are already any children except a single text or a CData present.  Create
    // a Text object if there is nothing.  XXX Requires a factory method... ugh.
    virtual status_t        SetData(const char * data);
    virtual status_t        SetData(BString * data);
    virtual status_t        SetData(BRect * data);
    virtual status_t        SetData(BPoint * data);
    virtual status_t        SetData(int8 * data);
    virtual status_t        SetData(int16 * data);
    virtual status_t        SetData(int32 * data);
    virtual status_t        SetData(int64 * data);
    virtual status_t        SetData(uint8 * data);
    virtual status_t        SetData(uint16 * data);
    virtual status_t        SetData(uint32 * data);
    virtual status_t        SetData(uint64 * data);
    virtual status_t        SetData(bool * data);
    virtual status_t        SetData(float * data);
    virtual status_t        SetData(double * data);
    virtual status_t        SetData(rgb_color * data);
    
    virtual status_t        SetDataXPath(BContent * pathTo);
#endif


private:
    
    BContent            * _firstChild;
    BContent            * _lastChild;
    BNamedSet           _attributes;
    BNamedSet           _namespaces;
};


// XML Valued
// =====================================================================
// BValued does not attempt to coalesce anything like BElement does --
// they don't have children.
class BValued
{
public:
    
    // --- Getting Value ------------------------------------
    status_t                GetValue(const char ** value) const;
    status_t                GetValue(BString * value) const;

#if !_SMALL_XML_FOOTPRINT_
    status_t                GetValue(BRect * value) const;
    status_t                GetValue(BPoint * value) const;
    status_t                GetValue(int8 * value) const;
    status_t                GetValue(int16 * value) const;
    status_t                GetValue(int32 * value) const;
    status_t                GetValue(int64 * value) const;
    status_t                GetValue(uint8 * value) const;
    status_t                GetValue(uint16 * value) const;
    status_t                GetValue(uint32 * value) const;
    status_t                GetValue(uint64 * value) const;
    status_t                GetValue(bool * value) const;
    status_t                GetValue(float * value) const;
    status_t                GetValue(double * value) const;
    status_t                GetValue(rgb_color * value) const;
    virtual status_t        GetValueXPath(BContent ** pathTo);
#endif
    
                            // This function gets what you would see if you
                            // outputed to XML and read with StyledEdit.
    virtual void            GetValueRaw(BString & value) const;
    
    // --- Setting Value ------------------------------------
    virtual status_t        SetValue(const char * value);
    virtual status_t        SetValue(const char * value, int32 length);
    
                            // Adopt takes the buffer from value, so there
                            // is no copy.
    virtual status_t        SetValue(BString & value, bool adopt = false);
    
#if !_SMALL_XML_FOOTPRINT_
    virtual status_t        SetValue(BRect value);
    virtual status_t        SetValue(BPoint value);
    virtual status_t        SetValue(int8 value);
    virtual status_t        SetValue(int16 value);
    virtual status_t        SetValue(int32 value);
    virtual status_t        SetValue(int64 value);
    virtual status_t        SetValue(uint8 value);
    virtual status_t        SetValue(uint16 value);
    virtual status_t        SetValue(uint32 value);
    virtual status_t        SetValue(uint64 value);
    virtual status_t        SetValue(bool value);
    virtual status_t        SetValue(float value);
    virtual status_t        SetValue(double value);
    virtual status_t        SetValueRGBColor(rgb_color value);
    virtual status_t        SetValueHTMLColor(rgb_color value);
    virtual status_t        SetValueXPath(BContent * pathTo);
#endif

    // --- Useful Functions ---------------------------------
                            // Start will become the index of the first char (-1 for end)
                            // Len is the number of chars to replace/delete, etc. (-1 is all)
    virtual status_t        Append(const char * str);
    virtual status_t        Insert(const char * str, int32 start = -1);
    virtual status_t        Remove(int32 start = -1, int32 len = -1);
    virtual status_t        Replace(const char * str, int32 start = 0, int32 len = -1);
    
protected:
    // --- Validation ---------------------------------------
                            // Hook function.  Easier than re-implementing
                            // all of the virtual set functions
                            // Check to see if the new value is okay
                            // return fals if it's not
                            // default impl returns true to approve it
                            // e.g. used by attribute to validate types
    virtual status_t        ValidateValueChange(BString & newVal);
    
public:
    explicit                BValued(const BValued & copy);
                            BValued(const char * value);
                            BValued(const BString & copy);
                            BValued();
    virtual                 ~BValued();
    
protected:
    // Give access just for efficiency.
    // Do not change this value directly, because ValidateValueChange will not be called.
    BString                 _value;
};


// XML Attribute
// =====================================================================
// Elements are stored as a set of attributes and an ordered set of children
// nodes.  This is the object that represents attributes.
// All the value methods come from the BXMLValued class
class BAttribute    : public BValued, public BNamed, public BXMLObject
{
public:
                            BAttribute(const char * name);
                            BAttribute(const char * name, const char * value);
                            BAttribute(const BString & name);
                            BAttribute(BString & name, bool adopt = false);
                            BAttribute(const BAttribute & copy); // deep copy
    virtual                 ~BAttribute();
    virtual BAttribute      * Clone() const;
    
                            // Properly esacpes meaningful xml characters
    virtual void            GetValueRaw(BString & value) const;
    
    virtual status_t        SetNamespace(BNamespace * space);
    using                   BNamed::Namespace;
    
private:
                            BAttribute();
};


// XML Processing Instruction
// =====================================================================
class BProcessingInstruction    : public BValued, public BNamed, public BContent
{
public:
                            BProcessingInstruction(const char * target);
                            BProcessingInstruction(const char * name, const char * value);
                            BProcessingInstruction(const BString & name);
                            BProcessingInstruction(BString & name, bool adopt = false);
                            BProcessingInstruction(const BProcessingInstruction & copy);    // deep copy
    
    virtual                 ~BProcessingInstruction();
    
    virtual BProcessingInstruction  * Clone() const;
    
    virtual void            GetValueRaw(BString & value) const;
private:
                            BProcessingInstruction();
};


// XML Text
// =====================================================================
// Text is character data that might get escaped when written to XML.
class BText : public BContent, public BValued
{
public:
                            BText();
                            BText(const BText & copy);
                            BText(const char * value);
                            BText(const BString & value);
    virtual                 ~BText();
    virtual BContent        * Clone() const;
};


// XML CData
// =====================================================================
// CData is text that does not get escaped, except for one case. It
// gets surrounded by the strings "<![CDATA[" and "]]>".  So if the
// string "]]>" appears in the string will be escaped to "]]&gt;"
// as required by Section 2.4 of the XML spec.
// The only difference between BText and BCData is how it is displayed
// in XML
class BCData : public BContent, public BValued
{
public:
                            BCData();
                            BCData(const BCData & copy);
                            BCData(const char * value);
                            BCData(const BString & value);
    virtual                 ~BCData();
    virtual BContent        * Clone() const;
};


// XML Comment
// =====================================================================
class BComment : public BContent, public BValued
{
public:
                            BComment();
                            BComment(const BComment & copy);
                            BComment(const char * value);
                            BComment(const BString & value);
    virtual                 ~BComment();
    virtual BContent        * Clone() const;
    
                            // Comments are escaped slightly differently
    virtual void            GetValueRaw(BString & value) const;
    
private:
                            // some substrings are illegal in comments
    virtual status_t        ValidateValueChange(BString & newVal);
};


// XML Document
// =====================================================================
// This class represents the document as a whole. It looks like an
// element, but it's not.  The document element has its parent set to NULL
// If it's NULL, you can always access the document through the Document() function.
// It's also not derived from BContent
// The document does not derive from element, but it has a bunch of similar
// functions, but it is much more limiting, because what a document can
// contain directly is limited by the XML spec.
class BDocument : public BXMLObject
{
public:
    
    // --- Constructor and Destructor  ----------------------
                            BDocument();
                            BDocument(const BDocument & copy);
    virtual                 ~BDocument();
    
    
    // --- Getting Children ---------------------------------
                            // Access to the first and last children for iteration
                            // iteration over all of the children of any type.
                            // With a mask, it will find the first that fits it
    BContent                * FirstChild();
    const BContent          * FirstChild() const;
    BContent                * FirstChild(uint32 typeMask);
    const BContent          * FirstChild(uint32 typeMask) const;
    BContent                * LastChild();
    const BContent          * LastChild() const;
    BContent                * LastChild(uint32 typeMask);
    const BContent          * LastChild(uint32 typeMask) const;

                            // Access to some of the interesting children
    BDocumentType           * DocumentType();
    const BDocumentType     * DocumentType() const;
    BElement                * Element();
    const BElement          * Element() const;
    
    
    // --- Adding Children ----------------------------------
                            // Make it the first one, take ownership of <content>
    virtual status_t        AddChildFirst(BContent * content);
                            // Make it the last one, take ownership of <content>
    virtual status_t        AddChildLast(BContent * content);
                            // Put it before <before>, take ownership of <content>
    virtual status_t        AddChildBefore(BContent * content, BContent * before);
                            // Put it after <after>, take ownership of <content>
    virtual status_t        AddChildAfter(BContent * content, BContent * after);
    
    // --- Removing Children --------------------------------
                            // Will not delete <content>
    virtual status_t        RemoveChild(BContent * content);
    

    // --- Some Interesting Functions -----------------------
                            // If there is a DTD, set it back to the default provided by
                            // the DTD.  If there isn't a DTD, empty it out.  Also deletes
                            // objects.  No leakage.
    // virtual status_t     ResetAll();
    // virtual status_t     ResetAttributes();
    // virtual status_t