source: icXML/icXML-devel/src/icxercesc/dom/impl/DOMNodeImpl.hpp

Last change on this file was 2721, checked in by cameron, 6 years ago

Fix imports in icXML modified Xerces files

File size: 17.2 KB
Line 
1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18/*
19 * $Id: DOMNodeImpl.hpp 671894 2008-06-26 13:29:21Z borisk $
20 */
21
22#if !defined(XERCESC_INCLUDE_GUARD_DOMNODEIMPL_HPP)
23#define XERCESC_INCLUDE_GUARD_DOMNODEIMPL_HPP
24
25//
26//  This file is part of the internal implementation of the C++ XML DOM.
27//  It should NOT be included or used directly by application programs.
28//
29//  Applications should include the file <xercesc/dom/DOM.hpp> for the entire
30//  DOM API, or xercesc/dom/DOM*.hpp for individual DOM classes, where the class
31//  name is substituded for the *.
32//
33
34/**
35 * A DOMNodeImpl doesn't have any children, and can therefore only be directly
36 * inherited by classes of nodes that never have any, such as Text nodes. For
37 * other types, such as Element, classes must inherit from ParentNode.
38 * <P>
39 * All nodes in a single document must originate
40 * in that document. (Note that this is much tighter than "must be
41 * same implementation") Nodes are all aware of their ownerDocument,
42 * and attempts to mismatch will throw WRONG_DOCUMENT_ERR.
43 * <P>
44 * However, to save memory not all nodes always have a direct reference
45 * to their ownerDocument. When a node is owned by another node it relies
46 * on its owner to store its ownerDocument. Parent nodes always store it
47 * though, so there is never more than one level of indirection.
48 * And when a node doesn't have an owner, ownerNode refers to its
49 * ownerDocument.
50 **/
51
52#include <xercesc/util/XercesDefs.hpp>
53#include <xercesc/dom/DOMUserDataHandler.hpp>
54#include <icxercesc/framework/XMLBuffer.hpp>
55
56XERCES_CPP_NAMESPACE_BEGIN
57
58
59class DOMNamedNodeMap;
60class DOMNodeList;
61class DOMNode;
62class DOMDocument;
63class DOMElement;
64
65class CDOM_EXPORT DOMNodeImpl {
66public:
67
68    // data
69    DOMNode                *fOwnerNode; // typically the parent but not always!
70
71    unsigned short flags;
72
73    static const unsigned short READONLY;
74    static const unsigned short SYNCDATA;
75    static const unsigned short SYNCCHILDREN;
76    static const unsigned short OWNED;
77    static const unsigned short FIRSTCHILD;
78    static const unsigned short SPECIFIED;
79    static const unsigned short IGNORABLEWS;
80    static const unsigned short SETVALUE;
81    static const unsigned short ID_ATTR;
82    static const unsigned short USERDATA;
83    static const unsigned short LEAFNODETYPE;
84    static const unsigned short CHILDNODE;
85    static const unsigned short TOBERELEASED;
86
87
88public:
89    DOMNodeImpl(DOMNode *ownerDocument);
90    DOMNodeImpl(const DOMNodeImpl &other);
91    ~DOMNodeImpl();
92
93    DOMNode         * appendChild(DOMNode *newChild);
94    DOMNamedNodeMap * getAttributes() const;
95    DOMNodeList     * getChildNodes() const;
96    DOMNode         * getFirstChild() const;
97    DOMNode         * getLastChild() const;
98    const XMLCh     * getLocalName() const;
99    const XMLCh     * getNamespaceURI() const;
100    DOMNode         * getNextSibling() const;
101    const XMLCh     * getNodeValue() const;
102    DOMDocument     * getOwnerDocument() const;
103    DOMNode         * getParentNode() const;
104    const XMLCh     * getPrefix() const;
105    DOMNode         * getPreviousSibling() const;
106    bool              hasChildNodes() const;
107    DOMNode         * insertBefore(DOMNode *newChild, DOMNode *refChild);
108    void              normalize();
109    DOMNode         * removeChild(DOMNode *oldChild);
110    DOMNode         * replaceChild(DOMNode *newChild, DOMNode *oldChild);
111    void              setNodeValue(const XMLCh *value);
112    void              setPrefix(const XMLCh *fPrefix);
113    void              setReadOnly(bool readOnly, bool deep);
114    bool              isSupported(const XMLCh *feature, const XMLCh *version) const;
115    bool              hasAttributes() const;
116
117    // Introduced in DOM Level 3
118    void*             setUserData(const XMLCh* key, void* data, DOMUserDataHandler* handler);
119    void*             getUserData(const XMLCh* key) const;
120    bool              isSameNode(const DOMNode* other) const;
121    bool              isEqualNode(const DOMNode* arg) const;
122    const XMLCh*      getBaseURI() const ;
123    short             compareDocumentPosition(const DOMNode* other) const;
124    const XMLCh*      getTextContent() const ;
125    const XMLCh*      getTextContent(XMLCh* pzBuffer, XMLSize_t& rnBufferLength) const;
126    void              setTextContent(const XMLCh* textContent) ;
127    const XMLCh*      lookupPrefix(const XMLCh* namespaceURI) const ;
128    bool              isDefaultNamespace(const XMLCh* namespaceURI) const ;
129    const XMLCh*      lookupNamespaceURI(const XMLCh* prefix) const  ;
130    void*             getFeature(const XMLCh* feature, const XMLCh* version) const;
131
132
133    // Helper functions for DOM Level 3
134    void              release();
135    void              callUserDataHandlers(DOMUserDataHandler::DOMOperationType operation,
136                                           const DOMNode* src,
137                                           DOMNode* dst) const;
138    //reverses the bit pattern given by compareDocumentPosition
139    short             reverseTreeOrderBitPattern(short pattern) const;
140    const DOMNode*    getTreeParentNode(const DOMNode* node) const;
141
142
143    //Utility, not part of DOM Level 2 API
144    static  bool      isKidOK(DOMNode *parent, DOMNode *child);
145    static const XMLCh *mapPrefix(const XMLCh *prefix,
146                               const XMLCh *namespaceURI, short nType);
147
148    static const XMLCh *getXmlnsString();
149    static const XMLCh *getXmlnsURIString();
150    static const XMLCh *getXmlString();
151    static const XMLCh *getXmlURIString();
152
153public: // should really be protected - ALH
154
155    DOMNode* getElementAncestor (const DOMNode* currentNode) const;
156    const XMLCh* lookupPrefix(const XMLCh* const namespaceURI, DOMElement *el) const ;
157    void setOwnerDocument(DOMDocument *doc);
158
159    /*
160     * Flags setters and getters
161     */
162
163    inline bool isReadOnly() const {
164        return (flags & READONLY) != 0;
165    }
166
167    inline void isReadOnly(bool value) {
168        flags = (value ? flags | READONLY : flags & ~READONLY);
169    }
170
171    inline bool needsSyncData() const {
172        return (flags & SYNCDATA) != 0;
173    }
174
175    inline void needsSyncData(bool value) {
176        flags = (value ? flags | SYNCDATA : flags & ~SYNCDATA);
177    }
178
179    inline bool needsSyncChildren() const {
180        return (flags & SYNCCHILDREN) != 0;
181    }
182
183    inline void needsSyncChildren(bool value) {
184        flags = (value ? flags | SYNCCHILDREN : flags & ~SYNCCHILDREN);
185    }
186
187    // For Attributes, true if the attr node is attached to an element.
188    // For all other node types, true if the node has a parent node.
189    inline bool isOwned() const {
190        return (flags & OWNED) != 0;
191    }
192
193    inline void isOwned(bool value) {
194        flags = (value ? flags | OWNED : flags & ~OWNED);
195    }
196
197    inline bool isFirstChild() const {
198        return (flags & FIRSTCHILD) != 0;
199    }
200
201    inline void isFirstChild(bool value) {
202        flags = (value ? flags | FIRSTCHILD : flags & ~FIRSTCHILD);
203    }
204
205    inline bool isSpecified() const {
206        return (flags & SPECIFIED) != 0;
207    }
208
209    inline void isSpecified(bool value) {
210        flags = (value ? flags | SPECIFIED : flags & ~SPECIFIED);
211    }
212
213    inline bool ignorableWhitespace() const {
214        return (flags & IGNORABLEWS) != 0;
215    }
216
217    inline void ignorableWhitespace(bool value) {
218        flags = (value ? flags | IGNORABLEWS : flags & ~IGNORABLEWS);
219    }
220
221    inline bool setValue() const {
222        return (flags & SETVALUE) != 0;
223    }
224
225    inline void setValue(bool value) {
226        flags = (value ? flags | SETVALUE : flags & ~SETVALUE);
227    }
228
229    inline bool isIdAttr() const {
230        return (flags & ID_ATTR) != 0;
231    }
232
233    inline void isIdAttr(bool value) {
234        flags = (value ? flags | ID_ATTR : flags & ~ID_ATTR);
235    }
236
237    inline bool hasUserData() const {
238        return (flags & USERDATA) != 0;
239    }
240
241    inline void hasUserData(bool value) {
242        flags = (value ? flags | USERDATA : flags & ~USERDATA);
243    }
244
245    //
246    //  LeafNode is set true for node types that can not be ParentNodes (can't have children)
247    //    This knowledge is used to allow casting from any unknown node type to the
248    //    IDParentImpl or IDChildImpl parts of the node.
249    //
250    inline bool isLeafNode() const {
251        return (flags & LEAFNODETYPE) != 0;
252    }
253
254    inline void setIsLeafNode(bool value) {
255        flags = (value ? flags | LEAFNODETYPE : flags & ~LEAFNODETYPE);
256    }
257
258
259    //
260    // ChildNode is set true for node types that can be children of other nodes, and
261    //   therefore include a DOMChildNode data member.  Note that all of the leaf
262    //   node types (above flag) are also ChildNodes, but not all ChildNodes are
263    //   leaf nodes.
264    inline bool isChildNode() const {
265        return (flags & CHILDNODE) != 0;
266    }
267
268    inline void setIsChildNode(bool value) {
269        flags = (value ? flags | CHILDNODE : flags & ~CHILDNODE);
270    }
271
272    // True if this node has to be released regardless if it has a owner or not
273    // This is true if called from fParent->release()
274    inline bool isToBeReleased() const {
275        return (flags & TOBERELEASED) != 0;
276    }
277
278    inline void isToBeReleased(bool value) {
279        flags = (value ? flags | TOBERELEASED : flags & ~TOBERELEASED);
280    }
281
282};
283
284
285// This macro lists all of the pure virtual functions declared in DOMNode that must
286//   be implemented by all node types.  Since there is no inheritance of implementation,
287//   using this macro in the class declaration of the node types make it easier to
288//   accurately get all of the functions declared.
289//
290#define DOMNODE_FUNCTIONS \
291    virtual       DOMNode*         appendChild(DOMNode *newChild) ;\
292    virtual       DOMNode*         cloneNode(bool deep) const ;\
293    virtual       DOMNamedNodeMap* getAttributes() const ;\
294    virtual       DOMNodeList*     getChildNodes() const ;\
295    virtual       DOMNode*         getFirstChild() const ;\
296    virtual       DOMNode*         getLastChild() const ;\
297    virtual const XMLCh*           getLocalName() const ;\
298    virtual const XMLCh*           getNamespaceURI() const ;\
299    virtual       DOMNode*         getNextSibling() const ;\
300    virtual const XMLCh*           getNodeName() const ;\
301    virtual       NodeType         getNodeType() const ;\
302    virtual const XMLCh*           getNodeValue() const ;\
303    virtual       DOMDocument*     getOwnerDocument() const ;\
304    virtual const XMLCh*           getPrefix() const ;\
305    virtual       DOMNode*         getParentNode() const ;\
306    virtual       DOMNode*         getPreviousSibling() const ;\
307    virtual       bool             hasChildNodes() const ;\
308    virtual       DOMNode*         insertBefore(DOMNode *newChild, DOMNode *refChild) ;\
309    virtual       void             normalize() ;\
310    virtual       DOMNode*         removeChild(DOMNode *oldChild) ;\
311    virtual       DOMNode*         replaceChild(DOMNode *newChild, DOMNode *oldChild) ;\
312    virtual       void             setNodeValue(const XMLCh  *nodeValue) ;\
313    virtual       bool             isSupported(const XMLCh *feature, const XMLCh *version) const ;\
314    virtual       bool             hasAttributes() const ;\
315    virtual       void             setPrefix(const XMLCh * prefix) ;\
316    virtual       void*            setUserData(const XMLCh* key, void* data, DOMUserDataHandler* handler) ;\
317    virtual       void*            getUserData(const XMLCh* key) const ;\
318    virtual       bool             isSameNode(const DOMNode* other) const;\
319    virtual       bool             isEqualNode(const DOMNode* arg) const;\
320    virtual const XMLCh*           getBaseURI() const ;\
321    virtual short                  compareDocumentPosition(const DOMNode* other) const ;\
322    virtual const XMLCh*           getTextContent() const ;\
323            const XMLCh*           getTextContent(XMLCh* pzBuffer, unsigned int& rnBufferLength) const;\
324    virtual void                   setTextContent(const XMLCh* textContent) ;\
325    virtual const XMLCh*           lookupPrefix(const XMLCh* namespaceURI) const  ;\
326    virtual bool                   isDefaultNamespace(const XMLCh* namespaceURI) const;\
327    virtual const XMLCh*           lookupNamespaceURI(const XMLCh* prefix) const  ;\
328    virtual       void*            getFeature(const XMLCh* feature, const XMLCh* version) const ;\
329    virtual       void             release()
330
331
332/*
333 *  Here are dummy stubs for most of the functions introduced by DOMNode.
334 *    Each subclass of DOMNode will have something like this that delegates each
335 *    function to the appropriate implementation.
336 *    Functions that must be supplied by every node class are omitted.
337 *
338           DOMNode*         xxx::appendChild(DOMNode *newChild)          {return fParent.appendChild (newChild); };
339           DOMNamedNodeMap* xxx::getAttributes() const                   {return fNode.getAttributes (); };
340           DOMNodeList*     xxx::getChildNodes() const                   {return fParent.getChildNodes (); };
341           DOMNode*         xxx::getFirstChild() const                   {return fParent.getFirstChild (); };
342           DOMNode*         xxx::getLastChild() const                    {return fParent.getLastChild (); };
343     const XMLCh*           xxx::getLocalName() const                    {return fNode.getLocalName (); };
344     const XMLCh*           xxx::getNamespaceURI() const                 {return fNode.getNamespaceURI (); };
345           DOMNode*         xxx::getNextSibling() const                  {return fChild.getNextSibling (); };
346     const XMLCh*           xxx::getNodeValue() const                    {return fNode.getNodeValue (); };
347           DOMDocument*     xxx::getOwnerDocument() const                {return fNode.getOwnerDocument (); };
348     const XMLCh*           xxx::getPrefix() const                       {return fNode.getPrefix (); };
349           DOMNode*         xxx::getParentNode() const                   {return fChild.getParentNode (this); };
350           DOMNode*         xxx::getPreviousSibling() const              {return fChild.getPreviousSibling (this); };
351           bool             xxx::hasChildNodes() const                   {return fParent.hasChildNodes (); };
352           DOMNode*         xxx::insertBefore(DOMNode *newChild, DOMNode *refChild)
353                                                                         {return fParent.insertBefore (newChild, refChild); };
354           void             xxx::normalize()                             {fParent.normalize(); };
355           DOMNode*         xxx::removeChild(DOMNode *oldChild)          {return fParent.removeChild (oldChild); };
356           DOMNode*         xxx::replaceChild(DOMNode *newChild, DOMNode *oldChild)
357                                                                         {return fParent.replaceChild (newChild, oldChild); };
358           bool             xxx::isSupported(const XMLCh *feature, const XMLCh *version) const
359                                                                         {return fNode.isSupported (feature, version); };
360           void             xxx::setPrefix(const XMLCh  *prefix)         {fNode.setPrefix(prefix); };
361           bool             xxx::hasAttributes() const                   {return fNode.hasAttributes(); };
362           bool             xxx::isSameNode(const DOMNode* other) const  {return fNode.isSameNode(other); };
363           bool             xxx::isEqualNode(const DOMNode* arg) const   {return fNode.isEqualNode(arg); };
364           void*            xxx::setUserData(const XMLCh* key, void* data, DOMUserDataHandler* handler)
365                                                                         {return fNode.setUserData(key, data, handler); };
366           void*            xxx::getUserData(const XMLCh* key) const     {return fNode.getUserData(key); };
367           const XMLCh*     xxx::getBaseURI() const                      {return fNode.getBaseURI(); };
368           short            xxx::compareDocumentPosition(const DOMNode* other) const {return fNode.compareDocumentPosition(other); };
369           const XMLCh*     xxx::getTextContent() const                  {return fNode.getTextContent(); };
370           void             xxx::setTextContent(const XMLCh* textContent){fNode.setTextContent(textContent); };
371           const XMLCh*     xxx::lookupPrefix(const XMLCh* namespaceURI) const {return fNode.lookupPrefix(namespaceURI); };
372           bool             xxx::isDefaultNamespace(const XMLCh* namespaceURI) const {return fNode.isDefaultNamespace(namespaceURI); };
373           const XMLCh*     xxx::lookupNamespaceURI(const XMLCh* prefix) const {return fNode.lookupNamespaceURI(prefix); };
374           void*            xxx::getFeature(const XMLCh* feature, const XMLCh* version) const {return fNode.getFeature(feature, version); };
375
376
377*/
378
379
380
381XERCES_CPP_NAMESPACE_END
382
383#endif
Note: See TracBrowser for help on using the repository browser.