domnode.h

// Copyright (c) 1999-2018 David Muse
// See the COPYING file for more information.
 
#ifndef RUDIMENTS_DOMNODE_H
#define RUDIMENTS_DOMNODE_H
 
#include <rudiments/private/domnodeincludes.h>
 
enum domnodetype {
        NULL_DOMNODETYPE=0,
        ROOT_DOMNODETYPE,
        TAG_DOMNODETYPE,
        ATTRIBUTE_DOMNODETYPE,
        TEXT_DOMNODETYPE,
        COMMENT_DOMNODETYPE,
        CDATA_DOMNODETYPE
};
 
class dom;
 
class RUDIMENTS_DLLSPEC domnode : virtual public object {
        public:
                domnode(dom *dom);
 
                domnode(dom *dom, domnodetype type,
                                        const char *name,
                                        const char *value);
 
                domnode(dom *dom, domnodetype type,
                                        const char *ns,
                                        const char *name,
                                        const char *value);
 
                virtual ~domnode();
 
 
                static  domnode *createNullNode(dom *dom);
 
 
                virtual domnodetype     getType();
 
                virtual const char      *getNamespace();
 
                virtual const char      *getName();
 
                virtual const char      *getValue();
 
 
                dom     *getTree();
 
                virtual domnode *getParent();
 
                virtual uint64_t        getPosition();
 
                virtual domnode *getPreviousSibling();
 
                domnode *getPreviousTagSibling();
 
                domnode *getPreviousTagSibling(const char *name);
 
                domnode *getPreviousTagSibling(const char *ns,
                                                const char *name);
 
                domnode *getPreviousTagSiblingIgnoringCase(
                                                const char *name);
 
                domnode *getPreviousTagSiblingIgnoringCase(
                                                const char *ns,
                                                const char *name);
 
                domnode *getPreviousTagSibling(
                                        const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                domnode *getPreviousTagSibling(
                                        const char *ns,
                                        const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                domnode *getPreviousTagSiblingIgnoringCase(
                                        const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                domnode *getPreviousTagSiblingIgnoringCase(
                                        const char *ns,
                                        const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                virtual domnode *getNextSibling();
 
                domnode *getNextTagSibling();
 
                domnode *getNextTagSibling(const char *name);
 
                domnode *getNextTagSibling(const char *ns,
                                                const char *name);
 
                domnode *getNextTagSiblingIgnoringCase(
                                                const char *name);
 
                domnode *getNextTagSiblingIgnoringCase(
                                                const char *ns,
                                                const char *name);
 
                domnode *getNextTagSibling(
                                        const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                domnode *getNextTagSibling(
                                        const char *ns,
                                        const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                domnode *getNextTagSiblingIgnoringCase(
                                        const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                domnode *getNextTagSiblingIgnoringCase(
                                        const char *ns,
                                        const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                domnode *getNextTagSiblingInSet(
                                        const char * const *set);
 
                domnode *getNextTagSiblingInSet(
                                        const char *ns,
                                        const char * const *set);
 
 
                virtual uint64_t        getChildCount();
 
                virtual domnode *getFirstChild();
 
                domnode *getFirstChild(const char *name);
 
                domnode *getFirstChild(const char *ns,
                                                const char *name);
 
                domnode *getFirstChildIgnoringCase(
                                                const char *name);
 
                domnode *getFirstChildIgnoringCase(
                                                const char *ns,
                                                const char *name);
 
                domnode *getChild(uint64_t position);
 
                domnode *getFirstChild(const char *name,
                                                const char *attributename,
                                                const char *attributevalue);
 
                domnode *getFirstChild(const char *ns,
                                                const char *name,
                                                const char *attributename,
                                                const char *attributevalue);
 
                domnode *getFirstChildIgnoringCase(
                                                const char *name,
                                                const char *attributename,
                                                const char *attributevalue);
 
                domnode *getFirstChildIgnoringCase(
                                                const char *ns,
                                                const char *name,
                                                const char *attributename,
                                                const char *attributevalue);
 
                domnode *getFirstTagChild();
 
                domnode *getFirstTagChild(const char *name);
 
                domnode *getFirstTagChild(const char *ns,
                                                const char *name);
 
                domnode *getFirstTagChildIgnoringCase(
                                                const char *name);
 
                domnode *getFirstTagChildIgnoringCase(
                                                const char *ns,
                                                const char *name);
 
                domnode *getFirstTagChild(
                                        const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                domnode *getFirstTagChild(
                                        const char *ns,
                                        const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                domnode *getFirstTagChildIgnoringCase(
                                        const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                domnode *getFirstTagChildIgnoringCase(
                                        const char *ns,
                                        const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                domnode *getFirstTagChildInSet(
                                        const char * const *set);
 
                domnode *getFirstTagChildInSet(
                                        const char *ns,
                                        const char * const *set);
 
 
                domnode *getFirstTagDescendent(const char *name);
 
 
                domnode *getFirstTagDescendent(
                                                const char *ns,
                                                const char *name);
 
 
                domnode *getFirstTagDescendentIgnoringCase(
                                                        const char *name);
 
 
                domnode *getFirstTagDescendentIgnoringCase(
                                                const char *ns,
                                                const char *name);
 
                domnode *getFirstTagDescendent(
                                        const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                domnode *getFirstTagDescendent(
                                        const char *ns,
                                        const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                domnode *getFirstTagDescendentIgnoringCase(
                                        const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                domnode *getFirstTagDescendentIgnoringCase(
                                        const char *ns,
                                        const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                domnode *getFirstTagDescendentInSet(
                                        const char * const *set);
 
                domnode *getFirstTagDescendentInSet(
                                        const char *ns,
                                        const char * const *set);
 
                domnode *getNextTag();
 
                domnode *getNextTag(domnode *top);
 
                domnode *getPreviousTag();
 
                domnode *getPreviousTag(domnode *top);
 
 
                virtual uint64_t        getAttributeCount();
 
                virtual domnode *getAttribute(const char *name);
 
                virtual domnode *getAttributeIgnoringCase(
                                                const char *name);
 
                virtual domnode *getAttribute(uint64_t position);
 
                const char      *getAttributeValue(const char *name);
 
                const char      *getAttributeValue(uint64_t position);
 
                dictionary<const char *, const char *> *getAttributes();
 
                void    setAttributeValue(const char *name, const char *value);
 
                void    setAttributeValue(const char *name, int64_t value);
 
                void    setAttributeValue(const char *name, uint64_t value);
 
                domnode *getNullNode();
 
                virtual bool    isNullNode();
 
 
                virtual void    setType(domnodetype type);
 
                virtual void    setNamespace(const char *ns);
 
                virtual void    setName(const char *name);
 
                void    setName(const char *ns, const char *name);
 
                virtual void    setValue(const char *value);
 
                virtual void    setParent(domnode *parent);
 
                virtual void    setPreviousSibling(domnode *previous);
 
                virtual void    setNextSibling(domnode *next);
 
                bool    insertChild(domnode *child, uint64_t position);
 
                bool    appendChild(domnode *child);
 
                domnode *insertTag(const char *tag, uint64_t position);
 
                domnode *insertTag(const char *ns,
                                                const char *tag,
                                                uint64_t position);
 
                domnode *appendTag(const char *tag);
 
                domnode *appendTag(const char *ns, const char *tag);
 
                bool    moveChild(domnode *child,
                                        domnode *parent, uint64_t position);
 
                bool    deleteChild(uint64_t position);
 
                bool    deleteChild(domnode *child);
 
                bool    deleteFirstChild(const char *name);
 
                bool    deleteFirstChild(const char *ns, const char *name);
 
                bool    deleteFirstChildIgnoringCase(const char *name);
 
                bool    deleteFirstChildIgnoringCase(const char *ns,
                                                        const char *name);
 
                bool    deleteFirstChild(const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                bool    deleteFirstChild(const char *ns,
                                        const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                bool    deleteFirstChildIgnoringCase(
                                        const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                bool    deleteFirstChildIgnoringCase(
                                        const char *ns,
                                        const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                bool    deleteChildren();
 
                bool    deleteChildren(const char *name);
 
                bool    deleteChildren(const char *ns, const char *name);
 
                bool    deleteChildrenIgnoringCase(const char *name);
 
                bool    deleteChildrenIgnoringCase(const char *ns,
                                                        const char *name);
 
                bool    deleteChildren(const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                bool    deleteChildren(const char *ns,
                                        const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                bool    deleteChildrenIgnoringCase(
                                        const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                bool    deleteChildrenIgnoringCase(
                                        const char *ns,
                                        const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                bool    deleteDescendents(const char *name);
 
                bool    deleteDescendents(const char *ns,
                                                const char *name);
 
                bool    deleteDescendentsIgnoringCase(const char *name);
 
                bool    deleteDescendentsIgnoringCase(const char *ns,
                                                        const char *name);
 
                bool    deleteDescendents(const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                bool    deleteDescendents(const char *ns,
                                        const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                bool    deleteDescendentsIgnoringCase(
                                        const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
                bool    deleteDescendentsIgnoringCase(
                                        const char *ns,
                                        const char *name,
                                        const char *attributename,
                                        const char *attributevalue);
 
 
                bool    renameFirstChild(const char *oldname,
                                                const char *newname);
 
 
                bool    renameFirstChild(const char *oldns,
                                                const char *oldname,
                                                const char *newns,
                                                const char *newname);
 
                bool    renameFirstChildIgnoringCase(const char *oldname,
                                                        const char *newname);
 
                bool    renameFirstChildIgnoringCase(const char *oldns,
                                                        const char *oldname,
                                                        const char *newns,
                                                        const char *newname);
 
                bool    renameChildren(const char *oldname,
                                                const char *newname);
 
                bool    renameChildren(const char *oldns,
                                                const char *oldname,
                                                const char *newns,
                                                const char *newname);
 
                bool    renameChildrenIgnoringCase(const char *oldname,
                                                        const char *newname);
 
                bool    renameChildrenIgnoringCase(const char *oldns,
                                                        const char *oldname,
                                                        const char *newns,
                                                        const char *newname);
 
                bool    renameDescendents(const char *oldname,
                                                const char *newname);
 
                bool    renameDescendents(const char *oldns,
                                                const char *oldname,
                                                const char *newns,
                                                const char *newname);
 
                bool    renameDescendentsIgnoringCase(
                                                const char *oldname,
                                                const char *newname);
 
                bool    renameDescendentsIgnoringCase(
                                                const char *oldns,
                                                const char *oldname,
                                                const char *newns,
                                                const char *newname);
 
 
                bool    insertText(const char *value, uint64_t position);
 
                bool    appendText(const char *value);
 
                bool    insertAttribute(domnode *attribute,
                                                        uint64_t position);
 
                bool    appendAttribute(domnode *attribute);
 
                bool    insertAttribute(const char *name, const char *value,
                                                        uint64_t position);
 
                bool    appendAttribute(const char *name, const char *value);
 
                bool    deleteAttribute(uint64_t position);
 
                bool    deleteAttribute(const char *name);
 
                bool    deleteAttribute(domnode *attribute);
 
 
                bool    unwrapChild(domnode *child);
 
                bool    unwrapFirstChild(const char *name);
 
                bool    unwrapFirstChild(const char *ns, const char *name);
 
                bool    unwrapFirstChildIgnoringCase(const char *name);
 
                bool    unwrapFirstChildIgnoringCase(const char *ns,
                                                        const char *name);
 
                bool    unwrapChildren(const char *name);
 
                bool    unwrapChildren(const char *ns, const char *name);
 
                bool    unwrapChildrenIgnoringCase(const char *name);
 
                bool    unwrapChildrenIgnoringCase(const char *ns,
                                                        const char *name);
 
                bool    unwrapDescendents(const char *name);
 
                bool    unwrapDescendents(const char *ns, const char *name);
 
                bool    unwrapDescendentsIgnoringCase(const char *name);
 
                bool    unwrapDescendentsIgnoringCase(const char *ns,
                                                        const char *name);
 
 
                domnode *wrapChild(domnode *child,
                                                const char *name);
 
                domnode *wrapChild(domnode *child,
                                                const char *ns,
                                                const char *name);
 
                domnode *wrapChildren(domnode *startchild,
                                                domnode *endchild,
                                                const char *name);
 
                domnode *wrapChildren(domnode *startchild,
                                                domnode *endchild,
                                                const char *ns,
                                                const char *name);
 
                domnode *wrapChildren(const char *name);
 
                domnode *wrapChildren(const char *ns, const char *name);
 
 
                virtual domnode *clone();
 
                virtual domnode *clone(dom *dom);
 
 
                ssize_t write();
 
                ssize_t write(bool indent);
 
                ssize_t write(output *out);
 
                ssize_t write(output *out, bool indent);
 
                ssize_t writeXml();
 
                ssize_t writeXml(bool indent);
 
                ssize_t writeXml(output *out);
 
                ssize_t writeXml(output *out, bool indent);
 
                stringbuffer    *getPath();
 
                domnode *getChildByPath(const char *path);
 
                domnode *getAttributeByPath(const char *path,
                                                uint64_t position);
 
                domnode *getAttributeByPath(const char *path,
                                                        const char *name);
 
                const char      *getAttributeValueByPath(const char *path,
                                                uint64_t position);
 
                const char      *getAttributeValueByPath(const char *path,
                                                        const char *name);
 
                void    setData(void *data);
 
                void    *getData();
 
        #include <rudiments/private/domnode.h>
};
 
#endif