diff options
Diffstat (limited to 'src/xml/dom/qdom_p.h')
| -rw-r--r-- | src/xml/dom/qdom_p.h | 540 |
1 files changed, 540 insertions, 0 deletions
diff --git a/src/xml/dom/qdom_p.h b/src/xml/dom/qdom_p.h new file mode 100644 index 0000000000..a9399d9901 --- /dev/null +++ b/src/xml/dom/qdom_p.h @@ -0,0 +1,540 @@ +/**************************************************************************** +** +** Copyright (C) 2019 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtXml module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ +#ifndef QDOM_P_H +#define QDOM_P_H + +#include "qdom.h" + +#include <qglobal.h> +#include <qhash.h> +#include <qstring.h> +#include <qlist.h> +#include <qxml.h> + +QT_BEGIN_NAMESPACE + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists for the convenience of +// qxml.cpp and qdom.cpp. This header file may change from version to version without +// notice, or even be removed. +// +// We mean it. +// + +/************************************************************** + * + * Private class declerations + * + **************************************************************/ + +class QDomImplementationPrivate +{ +public: + inline QDomImplementationPrivate() {} + + QDomImplementationPrivate *clone(); + QAtomicInt ref; + static QDomImplementation::InvalidDataPolicy invalidDataPolicy; +}; + +class QDomNodePrivate +{ +public: + QDomNodePrivate(QDomDocumentPrivate *, QDomNodePrivate *parent = nullptr); + QDomNodePrivate(QDomNodePrivate *n, bool deep); + virtual ~QDomNodePrivate(); + + QString nodeName() const { return name; } + QString nodeValue() const { return value; } + virtual void setNodeValue(const QString &v) { value = v; } + + QDomDocumentPrivate *ownerDocument(); + void setOwnerDocument(QDomDocumentPrivate *doc); + + virtual QDomNodePrivate *insertBefore(QDomNodePrivate *newChild, QDomNodePrivate *refChild); + virtual QDomNodePrivate *insertAfter(QDomNodePrivate *newChild, QDomNodePrivate *refChild); + virtual QDomNodePrivate *replaceChild(QDomNodePrivate *newChild, QDomNodePrivate *oldChild); + virtual QDomNodePrivate *removeChild(QDomNodePrivate *oldChild); + virtual QDomNodePrivate *appendChild(QDomNodePrivate *newChild); + + QDomNodePrivate *namedItem(const QString &name); + + virtual QDomNodePrivate *cloneNode(bool deep = true); + virtual void normalize(); + virtual void clear(); + + inline QDomNodePrivate *parent() const { return hasParent ? ownerNode : nullptr; } + inline void setParent(QDomNodePrivate *p) + { + ownerNode = p; + hasParent = true; + } + + void setNoParent() + { + ownerNode = hasParent ? (QDomNodePrivate *)ownerDocument() : nullptr; + hasParent = false; + } + + // Dynamic cast + bool isAttr() const { return nodeType() == QDomNode::AttributeNode; } + bool isCDATASection() const { return nodeType() == QDomNode::CDATASectionNode; } + bool isDocumentFragment() const { return nodeType() == QDomNode::DocumentFragmentNode; } + bool isDocument() const { return nodeType() == QDomNode::DocumentNode; } + bool isDocumentType() const { return nodeType() == QDomNode::DocumentTypeNode; } + bool isElement() const { return nodeType() == QDomNode::ElementNode; } + bool isEntityReference() const { return nodeType() == QDomNode::EntityReferenceNode; } + bool isText() const + { + const QDomNode::NodeType nt = nodeType(); + return (nt == QDomNode::TextNode) || (nt == QDomNode::CDATASectionNode); + } + bool isEntity() const { return nodeType() == QDomNode::EntityNode; } + bool isNotation() const { return nodeType() == QDomNode::NotationNode; } + bool isProcessingInstruction() const + { + return nodeType() == QDomNode::ProcessingInstructionNode; + } + bool isCharacterData() const + { + const QDomNode::NodeType nt = nodeType(); + return (nt == QDomNode::CharacterDataNode) || (nt == QDomNode::TextNode) + || (nt == QDomNode::CommentNode); + } + bool isComment() const { return nodeType() == QDomNode::CommentNode; } + + virtual QDomNode::NodeType nodeType() const { return QDomNode::BaseNode; } + + virtual void save(QTextStream &, int, int) const; + + void setLocation(int lineNumber, int columnNumber); + + // Variables + QAtomicInt ref; + QDomNodePrivate *prev; + QDomNodePrivate *next; + QDomNodePrivate *ownerNode; // either the node's parent or the node's owner document + QDomNodePrivate *first; + QDomNodePrivate *last; + + QString name; // this is the local name if prefix != null + QString value; + QString prefix; // set this only for ElementNode and AttributeNode + QString namespaceURI; // set this only for ElementNode and AttributeNode + bool createdWithDom1Interface : 1; + bool hasParent : 1; + + int lineNumber; + int columnNumber; +}; + +class QDomNodeListPrivate +{ +public: + QDomNodeListPrivate(QDomNodePrivate *); + QDomNodeListPrivate(QDomNodePrivate *, const QString &); + QDomNodeListPrivate(QDomNodePrivate *, const QString &, const QString &); + ~QDomNodeListPrivate(); + + bool operator==(const QDomNodeListPrivate &) const; + bool operator!=(const QDomNodeListPrivate &) const; + + void createList(); + QDomNodePrivate *item(int index); + int length() const; + + QAtomicInt ref; + /* + This list contains the children of this node. + */ + QDomNodePrivate *node_impl; + QString tagname; + QString nsURI; + QList<QDomNodePrivate *> list; + long timestamp; +}; + +class QDomNamedNodeMapPrivate +{ +public: + QDomNamedNodeMapPrivate(QDomNodePrivate *); + ~QDomNamedNodeMapPrivate(); + + QDomNodePrivate *namedItem(const QString &name) const; + QDomNodePrivate *namedItemNS(const QString &nsURI, const QString &localName) const; + QDomNodePrivate *setNamedItem(QDomNodePrivate *arg); + QDomNodePrivate *setNamedItemNS(QDomNodePrivate *arg); + QDomNodePrivate *removeNamedItem(const QString &name); + QDomNodePrivate *item(int index) const; + int length() const; + bool contains(const QString &name) const; + bool containsNS(const QString &nsURI, const QString &localName) const; + + /** + * Remove all children from the map. + */ + void clearMap(); + bool isReadOnly() { return readonly; } + void setReadOnly(bool r) { readonly = r; } + bool isAppendToParent() { return appendToParent; } + /** + * If true, then the node will redirect insert/remove calls + * to its parent by calling QDomNodePrivate::appendChild or removeChild. + * In addition the map won't increase or decrease the reference count + * of the nodes it contains. + * + * By default this value is false and the map will handle reference counting + * by itself. + */ + void setAppendToParent(bool b) { appendToParent = b; } + + /** + * Creates a copy of the map. It is a deep copy + * that means that all children are cloned. + */ + QDomNamedNodeMapPrivate *clone(QDomNodePrivate *parent); + + // Variables + QAtomicInt ref; + QMultiHash<QString, QDomNodePrivate *> map; + QDomNodePrivate *parent; + bool readonly; + bool appendToParent; +}; + +class QDomDocumentTypePrivate : public QDomNodePrivate +{ +public: + QDomDocumentTypePrivate(QDomDocumentPrivate *, QDomNodePrivate *parent = nullptr); + QDomDocumentTypePrivate(QDomDocumentTypePrivate *n, bool deep); + ~QDomDocumentTypePrivate(); + void init(); + + // Reimplemented from QDomNodePrivate + QDomNodePrivate *cloneNode(bool deep = true) override; + QDomNodePrivate *insertBefore(QDomNodePrivate *newChild, QDomNodePrivate *refChild) override; + QDomNodePrivate *insertAfter(QDomNodePrivate *newChild, QDomNodePrivate *refChild) override; + QDomNodePrivate *replaceChild(QDomNodePrivate *newChild, QDomNodePrivate *oldChild) override; + QDomNodePrivate *removeChild(QDomNodePrivate *oldChild) override; + QDomNodePrivate *appendChild(QDomNodePrivate *newChild) override; + + QDomNode::NodeType nodeType() const override { return QDomNode::DocumentTypeNode; } + + void save(QTextStream &s, int, int) const override; + + // Variables + QDomNamedNodeMapPrivate *entities; + QDomNamedNodeMapPrivate *notations; + QString publicId; + QString systemId; + QString internalSubset; +}; + +class QDomDocumentFragmentPrivate : public QDomNodePrivate +{ +public: + QDomDocumentFragmentPrivate(QDomDocumentPrivate *, QDomNodePrivate *parent = nullptr); + QDomDocumentFragmentPrivate(QDomNodePrivate *n, bool deep); + + // Reimplemented from QDomNodePrivate + virtual QDomNodePrivate *cloneNode(bool deep = true) override; + QDomNode::NodeType nodeType() const override { return QDomNode::DocumentFragmentNode; } +}; + +class QDomCharacterDataPrivate : public QDomNodePrivate +{ +public: + QDomCharacterDataPrivate(QDomDocumentPrivate *, QDomNodePrivate *parent, const QString &data); + QDomCharacterDataPrivate(QDomCharacterDataPrivate *n, bool deep); + + int dataLength() const; + QString substringData(unsigned long offset, unsigned long count) const; + void appendData(const QString &arg); + void insertData(unsigned long offset, const QString &arg); + void deleteData(unsigned long offset, unsigned long count); + void replaceData(unsigned long offset, unsigned long count, const QString &arg); + + // Reimplemented from QDomNodePrivate + QDomNode::NodeType nodeType() const override { return QDomNode::CharacterDataNode; } + QDomNodePrivate *cloneNode(bool deep = true) override; +}; + +class QDomTextPrivate : public QDomCharacterDataPrivate +{ +public: + QDomTextPrivate(QDomDocumentPrivate *, QDomNodePrivate *parent, const QString &val); + QDomTextPrivate(QDomTextPrivate *n, bool deep); + + QDomTextPrivate *splitText(int offset); + + // Reimplemented from QDomNodePrivate + QDomNodePrivate *cloneNode(bool deep = true) override; + QDomNode::NodeType nodeType() const override { return QDomNode::TextNode; } + virtual void save(QTextStream &s, int, int) const override; +}; + +class QDomAttrPrivate : public QDomNodePrivate +{ +public: + QDomAttrPrivate(QDomDocumentPrivate *, QDomNodePrivate *, const QString &name); + QDomAttrPrivate(QDomDocumentPrivate *, QDomNodePrivate *, const QString &nsURI, + const QString &qName); + QDomAttrPrivate(QDomAttrPrivate *n, bool deep); + + bool specified() const; + + // Reimplemented from QDomNodePrivate + void setNodeValue(const QString &v) override; + QDomNodePrivate *cloneNode(bool deep = true) override; + QDomNode::NodeType nodeType() const override { return QDomNode::AttributeNode; } + virtual void save(QTextStream &s, int, int) const override; + + // Variables + bool m_specified; +}; + +class QDomElementPrivate : public QDomNodePrivate +{ +public: + QDomElementPrivate(QDomDocumentPrivate *, QDomNodePrivate *parent, const QString &name); + QDomElementPrivate(QDomDocumentPrivate *, QDomNodePrivate *parent, const QString &nsURI, + const QString &qName); + QDomElementPrivate(QDomElementPrivate *n, bool deep); + ~QDomElementPrivate(); + + QString attribute(const QString &name, const QString &defValue) const; + QString attributeNS(const QString &nsURI, const QString &localName, + const QString &defValue) const; + void setAttribute(const QString &name, const QString &value); + void setAttributeNS(const QString &nsURI, const QString &qName, const QString &newValue); + void removeAttribute(const QString &name); + QDomAttrPrivate *attributeNode(const QString &name); + QDomAttrPrivate *attributeNodeNS(const QString &nsURI, const QString &localName); + QDomAttrPrivate *setAttributeNode(QDomAttrPrivate *newAttr); + QDomAttrPrivate *setAttributeNodeNS(QDomAttrPrivate *newAttr); + QDomAttrPrivate *removeAttributeNode(QDomAttrPrivate *oldAttr); + bool hasAttribute(const QString &name); + bool hasAttributeNS(const QString &nsURI, const QString &localName); + + QString text(); + + // Reimplemented from QDomNodePrivate + QDomNamedNodeMapPrivate *attributes() { return m_attr; } + bool hasAttributes() { return (m_attr->length() > 0); } + QDomNode::NodeType nodeType() const override { return QDomNode::ElementNode; } + QDomNodePrivate *cloneNode(bool deep = true) override; + virtual void save(QTextStream &s, int, int) const override; + + // Variables + QDomNamedNodeMapPrivate *m_attr; +}; + +class QDomCommentPrivate : public QDomCharacterDataPrivate +{ +public: + QDomCommentPrivate(QDomDocumentPrivate *, QDomNodePrivate *parent, const QString &val); + QDomCommentPrivate(QDomCommentPrivate *n, bool deep); + + // Reimplemented from QDomNodePrivate + QDomNodePrivate *cloneNode(bool deep = true) override; + QDomNode::NodeType nodeType() const override { return QDomNode::CommentNode; } + virtual void save(QTextStream &s, int, int) const override; +}; + +class QDomCDATASectionPrivate : public QDomTextPrivate +{ +public: + QDomCDATASectionPrivate(QDomDocumentPrivate *, QDomNodePrivate *parent, const QString &val); + QDomCDATASectionPrivate(QDomCDATASectionPrivate *n, bool deep); + + // Reimplemented from QDomNodePrivate + QDomNodePrivate *cloneNode(bool deep = true) override; + QDomNode::NodeType nodeType() const override { return QDomNode::CDATASectionNode; } + virtual void save(QTextStream &s, int, int) const override; +}; + +class QDomNotationPrivate : public QDomNodePrivate +{ +public: + QDomNotationPrivate(QDomDocumentPrivate *, QDomNodePrivate *parent, const QString &name, + const QString &pub, const QString &sys); + QDomNotationPrivate(QDomNotationPrivate *n, bool deep); + + // Reimplemented from QDomNodePrivate + QDomNodePrivate *cloneNode(bool deep = true) override; + QDomNode::NodeType nodeType() const override { return QDomNode::NotationNode; } + virtual void save(QTextStream &s, int, int) const override; + + // Variables + QString m_sys; + QString m_pub; +}; + +class QDomEntityPrivate : public QDomNodePrivate +{ +public: + QDomEntityPrivate(QDomDocumentPrivate *, QDomNodePrivate *parent, const QString &name, + const QString &pub, const QString &sys, const QString ¬ation); + QDomEntityPrivate(QDomEntityPrivate *n, bool deep); + + // Reimplemented from QDomNodePrivate + QDomNodePrivate *cloneNode(bool deep = true) override; + QDomNode::NodeType nodeType() const override { return QDomNode::EntityNode; } + virtual void save(QTextStream &s, int, int) const override; + + // Variables + QString m_sys; + QString m_pub; + QString m_notationName; +}; + +class QDomEntityReferencePrivate : public QDomNodePrivate +{ +public: + QDomEntityReferencePrivate(QDomDocumentPrivate *, QDomNodePrivate *parent, const QString &name); + QDomEntityReferencePrivate(QDomNodePrivate *n, bool deep); + + // Reimplemented from QDomNodePrivate + QDomNodePrivate *cloneNode(bool deep = true) override; + QDomNode::NodeType nodeType() const override { return QDomNode::EntityReferenceNode; } + virtual void save(QTextStream &s, int, int) const override; +}; + +class QDomProcessingInstructionPrivate : public QDomNodePrivate +{ +public: + QDomProcessingInstructionPrivate(QDomDocumentPrivate *, QDomNodePrivate *parent, + const QString &target, const QString &data); + QDomProcessingInstructionPrivate(QDomProcessingInstructionPrivate *n, bool deep); + + // Reimplemented from QDomNodePrivate + QDomNodePrivate *cloneNode(bool deep = true) override; + QDomNode::NodeType nodeType() const override { return QDomNode::ProcessingInstructionNode; } + virtual void save(QTextStream &s, int, int) const override; +}; + +class QDomDocumentPrivate : public QDomNodePrivate +{ +public: + QDomDocumentPrivate(); + QDomDocumentPrivate(const QString &name); + QDomDocumentPrivate(QDomDocumentTypePrivate *dt); + QDomDocumentPrivate(QDomDocumentPrivate *n, bool deep); + ~QDomDocumentPrivate(); + +#if QT_DEPRECATED_SINCE(5, 15) +QT_WARNING_PUSH +QT_WARNING_DISABLE_DEPRECATED + bool setContent(QXmlInputSource *source, bool namespaceProcessing, QString *errorMsg, + int *errorLine, int *errorColumn); + bool setContent(QXmlInputSource *source, QXmlReader *reader, QXmlSimpleReader *simpleReader, + QString *errorMsg, int *errorLine, int *errorColumn); +QT_WARNING_POP +#endif + bool setContent(QXmlStreamReader *reader, bool namespaceProcessing, QString *errorMsg, + int *errorLine, int *errorColumn); + + // Attributes + QDomDocumentTypePrivate *doctype() { return type.data(); } + QDomImplementationPrivate *implementation() { return impl.data(); } + QDomElementPrivate *documentElement(); + + // Factories + QDomElementPrivate *createElement(const QString &tagName); + QDomElementPrivate *createElementNS(const QString &nsURI, const QString &qName); + QDomDocumentFragmentPrivate *createDocumentFragment(); + QDomTextPrivate *createTextNode(const QString &data); + QDomCommentPrivate *createComment(const QString &data); + QDomCDATASectionPrivate *createCDATASection(const QString &data); + QDomProcessingInstructionPrivate *createProcessingInstruction(const QString &target, + const QString &data); + QDomAttrPrivate *createAttribute(const QString &name); + QDomAttrPrivate *createAttributeNS(const QString &nsURI, const QString &qName); + QDomEntityReferencePrivate *createEntityReference(const QString &name); + + QDomNodePrivate *importNode(QDomNodePrivate *importedNode, bool deep); + + // Reimplemented from QDomNodePrivate + QDomNodePrivate *cloneNode(bool deep = true) override; + QDomNode::NodeType nodeType() const override { return QDomNode::DocumentNode; } + void clear() override; + + // Variables + QExplicitlySharedDataPointer<QDomImplementationPrivate> impl; + QExplicitlySharedDataPointer<QDomDocumentTypePrivate> type; + + void saveDocument(QTextStream &stream, const int indent, + QDomNode::EncodingPolicy encUsed) const; + + /* \internal + Counter for the QDomNodeListPrivate timestamps. + + This is a cache optimization, that might in some cases be effective. The + dilemma is that QDomNode::childNodes() returns a list, but the + implementation stores the children in a linked list. Hence, in order to + get the children out through childNodes(), a list must be populated each + time, which is O(N). + + DOM has the requirement of node references being live, see DOM Core + Level 3, 1.1.1 The DOM Structure Model, which means that changes to the + underlying documents must be reflected in node lists. + + This mechanism, nodeListTime, is a caching optimization that reduces the + amount of times the node list is rebuilt, by only doing so when the + document actually changes. However, a change to anywhere in any document + invalidate all lists, since no dependency tracking is done. + + It functions by that all modifying functions(insertBefore() and so on) + increment the count; each QDomNodeListPrivate copies nodeListTime on + construction, and compares its own value to nodeListTime in order to + determine whether it needs to rebuild. + + This is reentrant. The nodeListTime may overflow, but that's ok since we + check for equalness, not whether nodeListTime is smaller than the list's + stored timestamp. + */ + long nodeListTime; +}; + +QT_END_NAMESPACE + +#endif // QDOMHELPERS_P_H |