/**************************************************************************** | |
** | |
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). | |
** All rights reserved. | |
** Contact: Nokia Corporation (qt-info@nokia.com) | |
** | |
** This file is part of the QtXml module of the Qt Toolkit. | |
** | |
** $QT_BEGIN_LICENSE:LGPL$ | |
** GNU Lesser General Public License Usage | |
** This file may be used under the terms of the GNU Lesser General Public | |
** License version 2.1 as published by the Free Software Foundation and | |
** appearing in the file LICENSE.LGPL included in the packaging of this | |
** file. Please review the following information to ensure the GNU Lesser | |
** General Public License version 2.1 requirements will be met: | |
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. | |
** | |
** In addition, as a special exception, Nokia gives you certain additional | |
** rights. These rights are described in the Nokia Qt LGPL Exception | |
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. | |
** | |
** GNU General Public License Usage | |
** Alternatively, this file may be used under the terms of the GNU General | |
** Public License version 3.0 as published by the Free Software Foundation | |
** and appearing in the file LICENSE.GPL included in the packaging of this | |
** file. Please review the following information to ensure the GNU General | |
** Public License version 3.0 requirements will be met: | |
** http://www.gnu.org/copyleft/gpl.html. | |
** | |
** Other Usage | |
** Alternatively, this file may be used in accordance with the terms and | |
** conditions contained in a signed written agreement between you and Nokia. | |
** | |
** | |
** | |
** | |
** | |
** $QT_END_LICENSE$ | |
** | |
****************************************************************************/ | |
#include <qplatformdefs.h> | |
#include <qdom.h> | |
#include "private/qxmlutils_p.h" | |
#ifndef QT_NO_DOM | |
#include <qatomic.h> | |
#include <qbuffer.h> | |
#include <qhash.h> | |
#include <qiodevice.h> | |
#include <qlist.h> | |
#include <qregexp.h> | |
#include <qtextcodec.h> | |
#include <qtextstream.h> | |
#include <qxml.h> | |
#include <qvariant.h> | |
#include <qmap.h> | |
#include <qshareddata.h> | |
#include <qdebug.h> | |
#include <stdio.h> | |
QT_BEGIN_NAMESPACE | |
/* | |
### old todo comments -- I don't know if they still apply... | |
If the document dies, remove all pointers to it from children | |
which can not be deleted at this time. | |
If a node dies and has direct children which can not be deleted, | |
then remove the pointer to the parent. | |
createElement and friends create double reference counts. | |
*/ | |
/* ##### new TODOs: | |
Remove emtpy emthods in the *Private classes | |
Make a lot of the (mostly empty) methods in the public classes inline. | |
Specially constructors assignment operators and comparison operators are candidates. | |
The virtual isXxx functions in *Private can probably be replaced by inline methods checking the nodeType(). | |
*/ | |
/* | |
Reference counting: | |
Some simple rules: | |
1) If an intern object returns a pointer to another intern object | |
then the reference count of the returned object is not increased. | |
2) If an extern object is created and gets a pointer to some intern | |
object, then the extern object increases the intern objects reference count. | |
3) If an extern object is deleted, then it decreases the reference count | |
on its associated intern object and deletes it if nobody else hold references | |
on the intern object. | |
*/ | |
/* | |
Helper to split a qualified name in the prefix and local name. | |
*/ | |
static void qt_split_namespace(QString& prefix, QString& name, const QString& qName, bool hasURI) | |
{ | |
int i = qName.indexOf(QLatin1Char(':')); | |
if (i == -1) { | |
if (hasURI) | |
prefix = QLatin1String(""); | |
else | |
prefix.clear(); | |
name = qName; | |
} else { | |
prefix = qName.left(i); | |
name = qName.mid(i + 1); | |
} | |
} | |
/************************************************************** | |
* | |
* Private class declerations | |
* | |
**************************************************************/ | |
class QDomImplementationPrivate | |
{ | |
public: | |
inline QDomImplementationPrivate() {} | |
QDomImplementationPrivate* clone(); | |
QAtomicInt ref; | |
static QDomImplementation::InvalidDataPolicy invalidDataPolicy; | |
}; | |
class QDomNodePrivate | |
{ | |
public: | |
QDomNodePrivate(QDomDocumentPrivate*, QDomNodePrivate* parent = 0); | |
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 : 0; } | |
inline void setParent(QDomNodePrivate *p) { ownerNode = p; hasParent = true; } | |
void setNoParent() { | |
ownerNode = hasParent ? (QDomNodePrivate*)ownerDocument() : 0; | |
hasParent = false; | |
} | |
// Dynamic cast | |
virtual bool isAttr() const { return false; } | |
virtual bool isCDATASection() const { return false; } | |
virtual bool isDocumentFragment() const { return false; } | |
virtual bool isDocument() const { return false; } | |
virtual bool isDocumentType() const { return false; } | |
virtual bool isElement() const { return false; } | |
virtual bool isEntityReference() const { return false; } | |
virtual bool isText() const { return false; } | |
virtual bool isEntity() const { return false; } | |
virtual bool isNotation() const { return false; } | |
virtual bool isProcessingInstruction() const { return false; } | |
virtual bool isCharacterData() const { return false; } | |
virtual bool isComment() const { return false; } | |
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); | |
uint 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; | |
uint 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 wont 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; | |
QHash<QString, QDomNodePrivate *> map; | |
QDomNodePrivate* parent; | |
bool readonly; | |
bool appendToParent; | |
}; | |
class QDomDocumentTypePrivate : public QDomNodePrivate | |
{ | |
public: | |
QDomDocumentTypePrivate(QDomDocumentPrivate*, QDomNodePrivate* parent = 0); | |
QDomDocumentTypePrivate(QDomDocumentTypePrivate* n, bool deep); | |
~QDomDocumentTypePrivate(); | |
void init(); | |
// Reimplemented from QDomNodePrivate | |
QDomNodePrivate* cloneNode(bool deep = true); | |
QDomNodePrivate* insertBefore(QDomNodePrivate* newChild, QDomNodePrivate* refChild); | |
QDomNodePrivate* insertAfter(QDomNodePrivate* newChild, QDomNodePrivate* refChild); | |
QDomNodePrivate* replaceChild(QDomNodePrivate* newChild, QDomNodePrivate* oldChild); | |
QDomNodePrivate* removeChild(QDomNodePrivate* oldChild); | |
QDomNodePrivate* appendChild(QDomNodePrivate* newChild); | |
virtual bool isDocumentType() const { return true; } | |
QDomNode::NodeType nodeType() const { return QDomNode::DocumentTypeNode; } | |
void save(QTextStream& s, int, int) const; | |
// Variables | |
QDomNamedNodeMapPrivate* entities; | |
QDomNamedNodeMapPrivate* notations; | |
QString publicId; | |
QString systemId; | |
QString internalSubset; | |
}; | |
class QDomDocumentFragmentPrivate : public QDomNodePrivate | |
{ | |
public: | |
QDomDocumentFragmentPrivate(QDomDocumentPrivate*, QDomNodePrivate* parent = 0); | |
QDomDocumentFragmentPrivate(QDomNodePrivate* n, bool deep); | |
// Reimplemented from QDomNodePrivate | |
virtual QDomNodePrivate* cloneNode(bool deep = true); | |
virtual bool isDocumentFragment() const { return true; } | |
QDomNode::NodeType nodeType() const { return QDomNode::DocumentFragmentNode; } | |
}; | |
class QDomCharacterDataPrivate : public QDomNodePrivate | |
{ | |
public: | |
QDomCharacterDataPrivate(QDomDocumentPrivate*, QDomNodePrivate* parent, const QString& data); | |
QDomCharacterDataPrivate(QDomCharacterDataPrivate* n, bool deep); | |
uint 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 | |
virtual bool isCharacterData() const { return true; } | |
QDomNode::NodeType nodeType() const { return QDomNode::CharacterDataNode; } | |
QDomNodePrivate* cloneNode(bool deep = true); | |
}; | |
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); | |
virtual bool isText() const { return true; } | |
QDomNode::NodeType nodeType() const { return QDomNode::TextNode; } | |
virtual void save(QTextStream& s, int, int) const; | |
}; | |
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); | |
QDomNodePrivate* cloneNode(bool deep = true); | |
virtual bool isAttr() const { return true; } | |
QDomNode::NodeType nodeType() const { return QDomNode::AttributeNode; } | |
virtual void save(QTextStream& s, int, int) const; | |
// 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); } | |
virtual bool isElement() const { return true; } | |
QDomNode::NodeType nodeType() const { return QDomNode::ElementNode; } | |
QDomNodePrivate* cloneNode(bool deep = true); | |
virtual void save(QTextStream& s, int, int) const; | |
// 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); | |
virtual bool isComment() const { return true; } | |
QDomNode::NodeType nodeType() const { return QDomNode::CommentNode; } | |
virtual void save(QTextStream& s, int, int) const; | |
}; | |
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); | |
virtual bool isCDATASection() const { return true; } | |
QDomNode::NodeType nodeType() const { return QDomNode::CDATASectionNode; } | |
virtual void save(QTextStream& s, int, int) const; | |
}; | |
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); | |
virtual bool isNotation() const { return true; } | |
QDomNode::NodeType nodeType() const { return QDomNode::NotationNode; } | |
virtual void save(QTextStream& s, int, int) const; | |
// 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& notation); | |
QDomEntityPrivate(QDomEntityPrivate* n, bool deep); | |
// Reimplemented from QDomNodePrivate | |
QDomNodePrivate* cloneNode(bool deep = true); | |
virtual bool isEntity() const { return true; } | |
QDomNode::NodeType nodeType() const { return QDomNode::EntityNode; } | |
virtual void save(QTextStream& s, int, int) const; | |
// 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); | |
bool isEntityReference() const { return true; } | |
QDomNode::NodeType nodeType() const { return QDomNode::EntityReferenceNode; } | |
virtual void save(QTextStream& s, int, int) const; | |
}; | |
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); | |
virtual bool isProcessingInstruction() const { return true; } | |
QDomNode::NodeType nodeType() const { return QDomNode::ProcessingInstructionNode; } | |
virtual void save(QTextStream& s, int, int) const; | |
}; | |
class QDomDocumentPrivate : public QDomNodePrivate | |
{ | |
public: | |
QDomDocumentPrivate(); | |
QDomDocumentPrivate(const QString& name); | |
QDomDocumentPrivate(QDomDocumentTypePrivate* dt); | |
QDomDocumentPrivate(QDomDocumentPrivate* n, bool deep); | |
~QDomDocumentPrivate(); | |
bool setContent(QXmlInputSource *source, bool namespaceProcessing, QString *errorMsg, int *errorLine, int *errorColumn); | |
bool setContent(QXmlInputSource *source, QXmlReader *reader, 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(const QDomNodePrivate* importedNode, bool deep); | |
// Reimplemented from QDomNodePrivate | |
QDomNodePrivate* cloneNode(bool deep = true); | |
bool isDocument() const { return true; } | |
QDomNode::NodeType nodeType() const { return QDomNode::DocumentNode; } | |
void clear(); | |
// 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; | |
}; | |
/************************************************************** | |
* | |
* QDomHandler | |
* | |
**************************************************************/ | |
class QDomHandler : public QXmlDefaultHandler | |
{ | |
public: | |
QDomHandler(QDomDocumentPrivate* d, bool namespaceProcessing); | |
~QDomHandler(); | |
// content handler | |
bool endDocument(); | |
bool startElement(const QString& nsURI, const QString& localName, const QString& qName, const QXmlAttributes& atts); | |
bool endElement(const QString& nsURI, const QString& localName, const QString& qName); | |
bool characters(const QString& ch); | |
bool processingInstruction(const QString& target, const QString& data); | |
bool skippedEntity(const QString& name); | |
// error handler | |
bool fatalError(const QXmlParseException& exception); | |
// lexical handler | |
bool startCDATA(); | |
bool endCDATA(); | |
bool startEntity(const QString &); | |
bool endEntity(const QString &); | |
bool startDTD(const QString& name, const QString& publicId, const QString& systemId); | |
bool comment(const QString& ch); | |
// decl handler | |
bool externalEntityDecl(const QString &name, const QString &publicId, const QString &systemId) ; | |
// DTD handler | |
bool notationDecl(const QString & name, const QString & publicId, const QString & systemId); | |
bool unparsedEntityDecl(const QString &name, const QString &publicId, const QString &systemId, const QString ¬ationName) ; | |
void setDocumentLocator(QXmlLocator *locator); | |
QString errorMsg; | |
int errorLine; | |
int errorColumn; | |
private: | |
QDomDocumentPrivate *doc; | |
QDomNodePrivate *node; | |
QString entityName; | |
bool cdata; | |
bool nsProcessing; | |
QXmlLocator *locator; | |
#ifdef Q_OS_SYMBIAN | |
// Workaround crash in elf2e32 under Wine. | |
virtual void dummy() {} | |
#endif | |
}; | |
/************************************************************** | |
* | |
* Functions for verifying legal data | |
* | |
**************************************************************/ | |
QDomImplementation::InvalidDataPolicy QDomImplementationPrivate::invalidDataPolicy | |
= QDomImplementation::AcceptInvalidChars; | |
// [5] Name ::= (Letter | '_' | ':') (NameChar)* | |
static QString fixedXmlName(const QString &_name, bool *ok, bool namespaces = false) | |
{ | |
QString name, prefix; | |
if (namespaces) | |
qt_split_namespace(prefix, name, _name, true); | |
else | |
name = _name; | |
if (name.isEmpty()) { | |
*ok = false; | |
return QString(); | |
} | |
if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::AcceptInvalidChars) { | |
*ok = true; | |
return _name; | |
} | |
QString result; | |
bool firstChar = true; | |
for (int i = 0; i < name.size(); ++i) { | |
QChar c = name.at(i); | |
if (firstChar) { | |
if (QXmlUtils::isLetter(c) || c.unicode() == '_' || c.unicode() == ':') { | |
result.append(c); | |
firstChar = false; | |
} else if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) { | |
*ok = false; | |
return QString(); | |
} | |
} else { | |
if (QXmlUtils::isNameChar(c)) | |
result.append(c); | |
else if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) { | |
*ok = false; | |
return QString(); | |
} | |
} | |
} | |
if (result.isEmpty()) { | |
*ok = false; | |
return QString(); | |
} | |
*ok = true; | |
if (namespaces && !prefix.isEmpty()) | |
return prefix + QLatin1Char(':') + result; | |
return result; | |
} | |
// [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*) | |
// '<', '&' and "]]>" will be escaped when writing | |
static QString fixedCharData(const QString &data, bool *ok) | |
{ | |
if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::AcceptInvalidChars) { | |
*ok = true; | |
return data; | |
} | |
QString result; | |
for (int i = 0; i < data.size(); ++i) { | |
QChar c = data.at(i); | |
if (QXmlUtils::isChar(c)) { | |
result.append(c); | |
} else if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) { | |
*ok = false; | |
return QString(); | |
} | |
} | |
*ok = true; | |
return result; | |
} | |
// [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->' | |
// can't escape "--", since entities are not recognised within comments | |
static QString fixedComment(const QString &data, bool *ok) | |
{ | |
if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::AcceptInvalidChars) { | |
*ok = true; | |
return data; | |
} | |
QString fixedData = fixedCharData(data, ok); | |
if (!*ok) | |
return QString(); | |
for (;;) { | |
int idx = fixedData.indexOf(QLatin1String("--")); | |
if (idx == -1) | |
break; | |
if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) { | |
*ok = false; | |
return QString(); | |
} | |
fixedData.remove(idx, 2); | |
} | |
*ok = true; | |
return fixedData; | |
} | |
// [20] CData ::= (Char* - (Char* ']]>' Char*)) | |
// can't escape "]]>", since entities are not recognised within comments | |
static QString fixedCDataSection(const QString &data, bool *ok) | |
{ | |
if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::AcceptInvalidChars) { | |
*ok = true; | |
return data; | |
} | |
QString fixedData = fixedCharData(data, ok); | |
if (!*ok) | |
return QString(); | |
for (;;) { | |
int idx = fixedData.indexOf(QLatin1String("]]>")); | |
if (idx == -1) | |
break; | |
if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) { | |
*ok = false; | |
return QString(); | |
} | |
fixedData.remove(idx, 3); | |
} | |
*ok = true; | |
return fixedData; | |
} | |
// [16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>' | |
static QString fixedPIData(const QString &data, bool *ok) | |
{ | |
if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::AcceptInvalidChars) { | |
*ok = true; | |
return data; | |
} | |
QString fixedData = fixedCharData(data, ok); | |
if (!*ok) | |
return QString(); | |
for (;;) { | |
int idx = fixedData.indexOf(QLatin1String("?>")); | |
if (idx == -1) | |
break; | |
if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) { | |
*ok = false; | |
return QString(); | |
} | |
fixedData.remove(idx, 2); | |
} | |
*ok = true; | |
return fixedData; | |
} | |
// [12] PubidLiteral ::= '"' PubidChar* '"' | "'" (PubidChar - "'")* "'" | |
// The correct quote will be chosen when writing | |
static QString fixedPubidLiteral(const QString &data, bool *ok) | |
{ | |
if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::AcceptInvalidChars) { | |
*ok = true; | |
return data; | |
} | |
QString result; | |
if(QXmlUtils::isPublicID(data)) | |
result = data; | |
else if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) { | |
*ok = false; | |
return QString(); | |
} | |
if (result.indexOf(QLatin1Char('\'')) != -1 | |
&& result.indexOf(QLatin1Char('"')) != -1) { | |
if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) { | |
*ok = false; | |
return QString(); | |
} else { | |
result.remove(QLatin1Char('\'')); | |
} | |
} | |
*ok = true; | |
return result; | |
} | |
// [11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'") | |
// The correct quote will be chosen when writing | |
static QString fixedSystemLiteral(const QString &data, bool *ok) | |
{ | |
if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::AcceptInvalidChars) { | |
*ok = true; | |
return data; | |
} | |
QString result = data; | |
if (result.indexOf(QLatin1Char('\'')) != -1 | |
&& result.indexOf(QLatin1Char('"')) != -1) { | |
if (QDomImplementationPrivate::invalidDataPolicy == QDomImplementation::ReturnNullNode) { | |
*ok = false; | |
return QString(); | |
} else { | |
result.remove(QLatin1Char('\'')); | |
} | |
} | |
*ok = true; | |
return result; | |
} | |
/************************************************************** | |
* | |
* QDomImplementationPrivate | |
* | |
**************************************************************/ | |
QDomImplementationPrivate* QDomImplementationPrivate::clone() | |
{ | |
return new QDomImplementationPrivate; | |
} | |
/************************************************************** | |
* | |
* QDomImplementation | |
* | |
**************************************************************/ | |
/*! | |
\class QDomImplementation | |
\reentrant | |
\brief The QDomImplementation class provides information about the | |
features of the DOM implementation. | |
\inmodule QtXml | |
\ingroup xml-tools | |
This class describes the features that are supported by the DOM | |
implementation. Currently the XML subset of DOM Level 1 and DOM | |
Level 2 Core are supported. | |
Normally you will use the function QDomDocument::implementation() | |
to get the implementation object. | |
You can create a new document type with createDocumentType() and a | |
new document with createDocument(). | |
For further information about the Document Object Model see | |
\l{http://www.w3.org/TR/REC-DOM-Level-1/}{Level 1} and | |
\l{http://www.w3.org/TR/DOM-Level-2-Core/}{Level 2 Core}. For a more | |
general introduction of the DOM implementation see the QDomDocument | |
documentation. | |
The QDom classes have a few issues of nonconformance with the XML | |
specifications that cannot be fixed in Qt 4 without breaking backward | |
compatibility. The QtXmlPatterns module and the QXmlStreamReader and | |
QXmlStreamWriter classes have a higher degree of a conformance. | |
\sa hasFeature() | |
*/ | |
/*! | |
Constructs a QDomImplementation object. | |
*/ | |
QDomImplementation::QDomImplementation() | |
{ | |
impl = 0; | |
} | |
/*! | |
Constructs a copy of \a x. | |
*/ | |
QDomImplementation::QDomImplementation(const QDomImplementation &x) | |
{ | |
impl = x.impl; | |
if (impl) | |
impl->ref.ref(); | |
} | |
QDomImplementation::QDomImplementation(QDomImplementationPrivate *p) | |
{ | |
// We want to be co-owners, so increase the reference count | |
impl = p; | |
if (impl) | |
impl->ref.ref(); | |
} | |
/*! | |
Assigns \a x to this DOM implementation. | |
*/ | |
QDomImplementation& QDomImplementation::operator=(const QDomImplementation &x) | |
{ | |
if (x.impl) | |
x.impl->ref.ref(); | |
if (impl && !impl->ref.deref()) | |
delete impl; | |
impl = x.impl; | |
return *this; | |
} | |
/*! | |
Returns true if \a x and this DOM implementation object were | |
created from the same QDomDocument; otherwise returns false. | |
*/ | |
bool QDomImplementation::operator==(const QDomImplementation &x) const | |
{ | |
return (impl == x.impl); | |
} | |
/*! | |
Returns true if \a x and this DOM implementation object were | |
created from different QDomDocuments; otherwise returns false. | |
*/ | |
bool QDomImplementation::operator!=(const QDomImplementation &x) const | |
{ | |
return (impl != x.impl); | |
} | |
/*! | |
Destroys the object and frees its resources. | |
*/ | |
QDomImplementation::~QDomImplementation() | |
{ | |
if (impl && !impl->ref.deref()) | |
delete impl; | |
} | |
/*! | |
The function returns true if QDom implements the requested \a | |
version of a \a feature; otherwise returns false. | |
The currently supported features and their versions: | |
\table | |
\header \i Feature \i Version | |
\row \i XML \i 1.0 | |
\endtable | |
*/ | |
bool QDomImplementation::hasFeature(const QString& feature, const QString& version) const | |
{ | |
if (feature == QLatin1String("XML")) { | |
if (version.isEmpty() || version == QLatin1String("1.0")) { | |
return true; | |
} | |
} | |
// ### add DOM level 2 features | |
return false; | |
} | |
/*! | |
Creates a document type node for the name \a qName. | |
\a publicId specifies the public identifier of the external | |
subset. If you specify an empty string (QString()) as the \a | |
publicId, this means that the document type has no public | |
identifier. | |
\a systemId specifies the system identifier of the external | |
subset. If you specify an empty string as the \a systemId, this | |
means that the document type has no system identifier. | |
Since you cannot have a public identifier without a system | |
identifier, the public identifier is set to an empty string if | |
there is no system identifier. | |
DOM level 2 does not support any other document type declaration | |
features. | |
The only way you can use a document type that was created this | |
way, is in combination with the createDocument() function to | |
create a QDomDocument with this document type. | |
In the DOM specification, this is the only way to create a non-null | |
document. For historical reasons, Qt also allows to create the | |
document using the default empty constructor. The resulting document | |
is null, but becomes non-null when a factory function, for example | |
QDomDocument::createElement(), is called. The document also becomes | |
non-null when setContent() is called. | |
\sa createDocument() | |
*/ | |
QDomDocumentType QDomImplementation::createDocumentType(const QString& qName, const QString& publicId, const QString& systemId) | |
{ | |
bool ok; | |
QString fixedName = fixedXmlName(qName, &ok, true); | |
if (!ok) | |
return QDomDocumentType(); | |
QString fixedPublicId = fixedPubidLiteral(publicId, &ok); | |
if (!ok) | |
return QDomDocumentType(); | |
QString fixedSystemId = fixedSystemLiteral(systemId, &ok); | |
if (!ok) | |
return QDomDocumentType(); | |
QDomDocumentTypePrivate *dt = new QDomDocumentTypePrivate(0); | |
dt->name = fixedName; | |
if (systemId.isNull()) { | |
dt->publicId.clear(); | |
dt->systemId.clear(); | |
} else { | |
dt->publicId = fixedPublicId; | |
dt->systemId = fixedSystemId; | |
} | |
dt->ref.deref(); | |
return QDomDocumentType(dt); | |
} | |
/*! | |
Creates a DOM document with the document type \a doctype. This | |
function also adds a root element node with the qualified name \a | |
qName and the namespace URI \a nsURI. | |
*/ | |
QDomDocument QDomImplementation::createDocument(const QString& nsURI, const QString& qName, const QDomDocumentType& doctype) | |
{ | |
QDomDocument doc(doctype); | |
QDomElement root = doc.createElementNS(nsURI, qName); | |
if (root.isNull()) | |
return QDomDocument(); | |
doc.appendChild(root); | |
return doc; | |
} | |
/*! | |
Returns false if the object was created by | |
QDomDocument::implementation(); otherwise returns true. | |
*/ | |
bool QDomImplementation::isNull() | |
{ | |
return (impl == 0); | |
} | |
/*! | |
\enum QDomImplementation::InvalidDataPolicy | |
This enum specifies what should be done when a factory function | |
in QDomDocument is called with invalid data. | |
\value AcceptInvalidChars The data should be stored in the DOM object | |
anyway. In this case the resulting XML document might not be well-formed. | |
This is the default value and QDom's behavior in Qt < 4.1. | |
\value DropInvalidChars The invalid characters should be removed from | |
the data. | |
\value ReturnNullNode The factory function should return a null node. | |
\sa setInvalidDataPolicy() invalidDataPolicy() | |
*/ | |
/*! | |
\enum QDomNode::EncodingPolicy | |
\since 4.3 | |
This enum specifies how QDomNode::save() determines what encoding to use | |
when serializing. | |
\value EncodingFromDocument The encoding is fetched from the document. | |
\value EncodingFromTextStream The encoding is fetched from the QTextStream. | |
See also the overload of the save() function that takes an EncodingPolicy. | |
*/ | |
/*! | |
\since 4.1 | |
\nonreentrant | |
Returns the invalid data policy, which specifies what should be done when | |
a factory function in QDomDocument is passed invalid data. | |
\sa setInvalidDataPolicy() InvalidDataPolicy | |
*/ | |
QDomImplementation::InvalidDataPolicy QDomImplementation::invalidDataPolicy() | |
{ | |
return QDomImplementationPrivate::invalidDataPolicy; | |
} | |
/*! | |
\since 4.1 | |
\nonreentrant | |
Sets the invalid data policy, which specifies what should be done when | |
a factory function in QDomDocument is passed invalid data. | |
The \a policy is set for all instances of QDomDocument which already | |
exist and which will be created in the future. | |
\snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 0 | |
\sa invalidDataPolicy() InvalidDataPolicy | |
*/ | |
void QDomImplementation::setInvalidDataPolicy(InvalidDataPolicy policy) | |
{ | |
QDomImplementationPrivate::invalidDataPolicy = policy; | |
} | |
/************************************************************** | |
* | |
* QDomNodeListPrivate | |
* | |
**************************************************************/ | |
QDomNodeListPrivate::QDomNodeListPrivate(QDomNodePrivate *n_impl) | |
{ | |
ref = 1; | |
node_impl = n_impl; | |
if (node_impl) | |
node_impl->ref.ref(); | |
timestamp = 0; | |
} | |
QDomNodeListPrivate::QDomNodeListPrivate(QDomNodePrivate *n_impl, const QString &name) | |
{ | |
ref = 1; | |
node_impl = n_impl; | |
if (node_impl) | |
node_impl->ref.ref(); | |
tagname = name; | |
timestamp = 0; | |
} | |
QDomNodeListPrivate::QDomNodeListPrivate(QDomNodePrivate *n_impl, const QString &_nsURI, const QString &localName) | |
{ | |
ref = 1; | |
node_impl = n_impl; | |
if (node_impl) | |
node_impl->ref.ref(); | |
tagname = localName; | |
nsURI = _nsURI; | |
timestamp = 0; | |
} | |
QDomNodeListPrivate::~QDomNodeListPrivate() | |
{ | |
if (node_impl && !node_impl->ref.deref()) | |
delete node_impl; | |
} | |
bool QDomNodeListPrivate::operator==(const QDomNodeListPrivate &other) const | |
{ | |
return (node_impl == other.node_impl) && (tagname == other.tagname); | |
} | |
bool QDomNodeListPrivate::operator!=(const QDomNodeListPrivate &other) const | |
{ | |
return (node_impl != other.node_impl) || (tagname != other.tagname); | |
} | |
void QDomNodeListPrivate::createList() | |
{ | |
if (!node_impl) | |
return; | |
const QDomDocumentPrivate *const doc = node_impl->ownerDocument(); | |
if (doc && timestamp != doc->nodeListTime) | |
timestamp = doc->nodeListTime; | |
QDomNodePrivate* p = node_impl->first; | |
list.clear(); | |
if (tagname.isNull()) { | |
while (p) { | |
list.append(p); | |
p = p->next; | |
} | |
} else if (nsURI.isNull()) { | |
while (p && p != node_impl) { | |
if (p->isElement() && p->nodeName() == tagname) { | |
list.append(p); | |
} | |
if (p->first) | |
p = p->first; | |
else if (p->next) | |
p = p->next; | |
else { | |
p = p->parent(); | |
while (p && p != node_impl && !p->next) | |
p = p->parent(); | |
if (p && p != node_impl) | |
p = p->next; | |
} | |
} | |
} else { | |
while (p && p != node_impl) { | |
if (p->isElement() && p->name==tagname && p->namespaceURI==nsURI) { | |
list.append(p); | |
} | |
if (p->first) | |
p = p->first; | |
else if (p->next) | |
p = p->next; | |
else { | |
p = p->parent(); | |
while (p && p != node_impl && !p->next) | |
p = p->parent(); | |
if (p && p != node_impl) | |
p = p->next; | |
} | |
} | |
} | |
} | |
QDomNodePrivate* QDomNodeListPrivate::item(int index) | |
{ | |
if (!node_impl) | |
return 0; | |
const QDomDocumentPrivate *const doc = node_impl->ownerDocument(); | |
if (!doc || timestamp != doc->nodeListTime) | |
createList(); | |
if (index >= list.size()) | |
return 0; | |
return list.at(index); | |
} | |
uint QDomNodeListPrivate::length() const | |
{ | |
if (!node_impl) | |
return 0; | |
const QDomDocumentPrivate *const doc = node_impl->ownerDocument(); | |
if (!doc || timestamp != doc->nodeListTime) { | |
QDomNodeListPrivate *that = const_cast<QDomNodeListPrivate *>(this); | |
that->createList(); | |
} | |
return list.count(); | |
} | |
/************************************************************** | |
* | |
* QDomNodeList | |
* | |
**************************************************************/ | |
/*! | |
\class QDomNodeList | |
\reentrant | |
\brief The QDomNodeList class is a list of QDomNode objects. | |
\inmodule QtXml | |
\ingroup xml-tools | |
Lists can be obtained by QDomDocument::elementsByTagName() and | |
QDomNode::childNodes(). The Document Object Model (DOM) requires | |
these lists to be "live": whenever you change the underlying | |
document, the contents of the list will get updated. | |
You can get a particular node from the list with item(). The | |
number of items in the list is returned by length(). | |
For further information about the Document Object Model see | |
\l{http://www.w3.org/TR/REC-DOM-Level-1/}{Level 1} and | |
\l{http://www.w3.org/TR/DOM-Level-2-Core/}{Level 2 Core}. | |
For a more general introduction of the DOM implementation see the | |
QDomDocument documentation. | |
\sa QDomNode::childNodes() QDomDocument::elementsByTagName() | |
*/ | |
/*! | |
Creates an empty node list. | |
*/ | |
QDomNodeList::QDomNodeList() | |
{ | |
impl = 0; | |
} | |
QDomNodeList::QDomNodeList(QDomNodeListPrivate* p) | |
{ | |
impl = p; | |
} | |
/*! | |
Constructs a copy of \a n. | |
*/ | |
QDomNodeList::QDomNodeList(const QDomNodeList& n) | |
{ | |
impl = n.impl; | |
if (impl) | |
impl->ref.ref(); | |
} | |
/*! | |
Assigns \a n to this node list. | |
*/ | |
QDomNodeList& QDomNodeList::operator=(const QDomNodeList &n) | |
{ | |
if (n.impl) | |
n.impl->ref.ref(); | |
if (impl && !impl->ref.deref()) | |
delete impl; | |
impl = n.impl; | |
return *this; | |
} | |
/*! | |
Returns true if the node list \a n and this node list are equal; | |
otherwise returns false. | |
*/ | |
bool QDomNodeList::operator==(const QDomNodeList &n) const | |
{ | |
if (impl == n.impl) | |
return true; | |
if (!impl || !n.impl) | |
return false; | |
return (*impl == *n.impl); | |
} | |
/*! | |
Returns true the node list \a n and this node list are not equal; | |
otherwise returns false. | |
*/ | |
bool QDomNodeList::operator!=(const QDomNodeList &n) const | |
{ | |
return !operator==(n); | |
} | |
/*! | |
Destroys the object and frees its resources. | |
*/ | |
QDomNodeList::~QDomNodeList() | |
{ | |
if (impl && !impl->ref.deref()) | |
delete impl; | |
} | |
/*! | |
Returns the node at position \a index. | |
If \a index is negative or if \a index >= length() then a null | |
node is returned (i.e. a node for which QDomNode::isNull() returns | |
true). | |
\sa length() | |
*/ | |
QDomNode QDomNodeList::item(int index) const | |
{ | |
if (!impl) | |
return QDomNode(); | |
return QDomNode(impl->item(index)); | |
} | |
/*! | |
Returns the number of nodes in the list. | |
*/ | |
uint QDomNodeList::length() const | |
{ | |
if (!impl) | |
return 0; | |
return impl->length(); | |
} | |
/*! | |
\fn bool QDomNodeList::isEmpty() const | |
Returns true if the list contains no items; otherwise returns false. | |
This function is provided for Qt API consistency. | |
*/ | |
/*! | |
\fn int QDomNodeList::count() const | |
This function is provided for Qt API consistency. It is equivalent to length(). | |
*/ | |
/*! | |
\fn int QDomNodeList::size() const | |
This function is provided for Qt API consistency. It is equivalent to length(). | |
*/ | |
/*! | |
\fn QDomNode QDomNodeList::at(int index) const | |
This function is provided for Qt API consistency. It is equivalent | |
to item(). | |
If \a index is negative or if \a index >= length() then a null | |
node is returned (i.e. a node for which QDomNode::isNull() returns | |
true). | |
*/ | |
/************************************************************** | |
* | |
* QDomNodePrivate | |
* | |
**************************************************************/ | |
inline void QDomNodePrivate::setOwnerDocument(QDomDocumentPrivate *doc) | |
{ | |
ownerNode = doc; | |
hasParent = false; | |
} | |
QDomNodePrivate::QDomNodePrivate(QDomDocumentPrivate *doc, QDomNodePrivate *par) | |
{ | |
ref = 1; | |
if (par) | |
setParent(par); | |
else | |
setOwnerDocument(doc); | |
prev = 0; | |
next = 0; | |
first = 0; | |
last = 0; | |
createdWithDom1Interface = true; | |
lineNumber = -1; | |
columnNumber = -1; | |
} | |
QDomNodePrivate::QDomNodePrivate(QDomNodePrivate *n, bool deep) | |
{ | |
ref = 1; | |
setOwnerDocument(n->ownerDocument()); | |
prev = 0; | |
next = 0; | |
first = 0; | |
last = 0; | |
name = n->name; | |
value = n->value; | |
prefix = n->prefix; | |
namespaceURI = n->namespaceURI; | |
createdWithDom1Interface = n->createdWithDom1Interface; | |
lineNumber = -1; | |
columnNumber = -1; | |
if (!deep) | |
return; | |
for (QDomNodePrivate* x = n->first; x; x = x->next) | |
appendChild(x->cloneNode(true)); | |
} | |
QDomNodePrivate::~QDomNodePrivate() | |
{ | |
QDomNodePrivate* p = first; | |
QDomNodePrivate* n; | |
while (p) { | |
n = p->next; | |
if (!p->ref.deref()) | |
delete p; | |
else | |
p->setNoParent(); | |
p = n; | |
} | |
first = 0; | |
last = 0; | |
} | |
void QDomNodePrivate::clear() | |
{ | |
QDomNodePrivate* p = first; | |
QDomNodePrivate* n; | |
while (p) { | |
n = p->next; | |
if (!p->ref.deref()) | |
delete p; | |
p = n; | |
} | |
first = 0; | |
last = 0; | |
} | |
QDomNodePrivate* QDomNodePrivate::namedItem(const QString &n) | |
{ | |
QDomNodePrivate* p = first; | |
while (p) { | |
if (p->nodeName() == n) | |
return p; | |
p = p->next; | |
} | |
return 0; | |
} | |
QDomNodePrivate* QDomNodePrivate::insertBefore(QDomNodePrivate* newChild, QDomNodePrivate* refChild) | |
{ | |
// Error check | |
if (!newChild) | |
return 0; | |
// Error check | |
if (newChild == refChild) | |
return 0; | |
// Error check | |
if (refChild && refChild->parent() != this) | |
return 0; | |
// "mark lists as dirty" | |
QDomDocumentPrivate *const doc = ownerDocument(); | |
if(doc) | |
doc->nodeListTime++; | |
// Special handling for inserting a fragment. We just insert | |
// all elements of the fragment instead of the fragment itself. | |
if (newChild->isDocumentFragment()) { | |
// Fragment is empty ? | |
if (newChild->first == 0) | |
return newChild; | |
// New parent | |
QDomNodePrivate* n = newChild->first; | |
while (n) { | |
n->setParent(this); | |
n = n->next; | |
} | |
// Insert at the beginning ? | |
if (!refChild || refChild->prev == 0) { | |
if (first) | |
first->prev = newChild->last; | |
newChild->last->next = first; | |
if (!last) | |
last = newChild->last; | |
first = newChild->first; | |
} else { | |
// Insert in the middle | |
newChild->last->next = refChild; | |
newChild->first->prev = refChild->prev; | |
refChild->prev->next = newChild->first; | |
refChild->prev = newChild->last; | |
} | |
// No need to increase the reference since QDomDocumentFragment | |
// does not decrease the reference. | |
// Remove the nodes from the fragment | |
newChild->first = 0; | |
newChild->last = 0; | |
return newChild; | |
} | |
// No more errors can occur now, so we take | |
// ownership of the node. | |
newChild->ref.ref(); | |
if (newChild->parent()) | |
newChild->parent()->removeChild(newChild); | |
newChild->setParent(this); | |
if (!refChild) { | |
if (first) | |
first->prev = newChild; | |
newChild->next = first; | |
if (!last) | |
last = newChild; | |
first = newChild; | |
return newChild; | |
} | |
if (refChild->prev == 0) { | |
if (first) | |
first->prev = newChild; | |
newChild->next = first; | |
if (!last) | |
last = newChild; | |
first = newChild; | |
return newChild; | |
} | |
newChild->next = refChild; | |
newChild->prev = refChild->prev; | |
refChild->prev->next = newChild; | |
refChild->prev = newChild; | |
return newChild; | |
} | |
QDomNodePrivate* QDomNodePrivate::insertAfter(QDomNodePrivate* newChild, QDomNodePrivate* refChild) | |
{ | |
// Error check | |
if (!newChild) | |
return 0; | |
// Error check | |
if (newChild == refChild) | |
return 0; | |
// Error check | |
if (refChild && refChild->parent() != this) | |
return 0; | |
// "mark lists as dirty" | |
QDomDocumentPrivate *const doc = ownerDocument(); | |
if(doc) | |
doc->nodeListTime++; | |
// Special handling for inserting a fragment. We just insert | |
// all elements of the fragment instead of the fragment itself. | |
if (newChild->isDocumentFragment()) { | |
// Fragment is empty ? | |
if (newChild->first == 0) | |
return newChild; | |
// New parent | |
QDomNodePrivate* n = newChild->first; | |
while (n) { | |
n->setParent(this); | |
n = n->next; | |
} | |
// Insert at the end | |
if (!refChild || refChild->next == 0) { | |
if (last) | |
last->next = newChild->first; | |
newChild->first->prev = last; | |
if (!first) | |
first = newChild->first; | |
last = newChild->last; | |
} else { // Insert in the middle | |
newChild->first->prev = refChild; | |
newChild->last->next = refChild->next; | |
refChild->next->prev = newChild->last; | |
refChild->next = newChild->first; | |
} | |
// No need to increase the reference since QDomDocumentFragment | |
// does not decrease the reference. | |
// Remove the nodes from the fragment | |
newChild->first = 0; | |
newChild->last = 0; | |
return newChild; | |
} | |
// Release new node from its current parent | |
if (newChild->parent()) | |
newChild->parent()->removeChild(newChild); | |
// No more errors can occur now, so we take | |
// ownership of the node | |
newChild->ref.ref(); | |
newChild->setParent(this); | |
// Insert at the end | |
if (!refChild) { | |
if (last) | |
last->next = newChild; | |
newChild->prev = last; | |
if (!first) | |
first = newChild; | |
last = newChild; | |
return newChild; | |
} | |
if (refChild->next == 0) { | |
if (last) | |
last->next = newChild; | |
newChild->prev = last; | |
if (!first) | |
first = newChild; | |
last = newChild; | |
return newChild; | |
} | |
newChild->prev = refChild; | |
newChild->next = refChild->next; | |
refChild->next->prev = newChild; | |
refChild->next = newChild; | |
return newChild; | |
} | |
QDomNodePrivate* QDomNodePrivate::replaceChild(QDomNodePrivate* newChild, QDomNodePrivate* oldChild) | |
{ | |
if (!newChild || !oldChild) | |
return 0; | |
if (oldChild->parent() != this) | |
return 0; | |
if (newChild == oldChild) | |
return 0; | |
// mark lists as dirty | |
QDomDocumentPrivate *const doc = ownerDocument(); | |
if(doc) | |
doc->nodeListTime++; | |
// Special handling for inserting a fragment. We just insert | |
// all elements of the fragment instead of the fragment itself. | |
if (newChild->isDocumentFragment()) { | |
// Fragment is empty ? | |
if (newChild->first == 0) | |
return newChild; | |
// New parent | |
QDomNodePrivate* n = newChild->first; | |
while (n) { | |
n->setParent(this); | |
n = n->next; | |
} | |
if (oldChild->next) | |
oldChild->next->prev = newChild->last; | |
if (oldChild->prev) | |
oldChild->prev->next = newChild->first; | |
newChild->last->next = oldChild->next; | |
newChild->first->prev = oldChild->prev; | |
if (first == oldChild) | |
first = newChild->first; | |
if (last == oldChild) | |
last = newChild->last; | |
oldChild->setNoParent(); | |
oldChild->next = 0; | |
oldChild->prev = 0; | |
// No need to increase the reference since QDomDocumentFragment | |
// does not decrease the reference. | |
// Remove the nodes from the fragment | |
newChild->first = 0; | |
newChild->last = 0; | |
// We are no longer interested in the old node | |
if (oldChild) | |
oldChild->ref.deref(); | |
return oldChild; | |
} | |
// No more errors can occur now, so we take | |
// ownership of the node | |
newChild->ref.ref(); | |
// Release new node from its current parent | |
if (newChild->parent()) | |
newChild->parent()->removeChild(newChild); | |
newChild->setParent(this); | |
if (oldChild->next) | |
oldChild->next->prev = newChild; | |
if (oldChild->prev) | |
oldChild->prev->next = newChild; | |
newChild->next = oldChild->next; | |
newChild->prev = oldChild->prev; | |
if (first == oldChild) | |
first = newChild; | |
if (last == oldChild) | |
last = newChild; | |
oldChild->setNoParent(); | |
oldChild->next = 0; | |
oldChild->prev = 0; | |
// We are no longer interested in the old node | |
if (oldChild) | |
oldChild->ref.deref(); | |
return oldChild; | |
} | |
QDomNodePrivate* QDomNodePrivate::removeChild(QDomNodePrivate* oldChild) | |
{ | |
// Error check | |
if (oldChild->parent() != this) | |
return 0; | |
// "mark lists as dirty" | |
QDomDocumentPrivate *const doc = ownerDocument(); | |
if(doc) | |
doc->nodeListTime++; | |
// Perhaps oldChild was just created with "createElement" or that. In this case | |
// its parent is QDomDocument but it is not part of the documents child list. | |
if (oldChild->next == 0 && oldChild->prev == 0 && first != oldChild) | |
return 0; | |
if (oldChild->next) | |
oldChild->next->prev = oldChild->prev; | |
if (oldChild->prev) | |
oldChild->prev->next = oldChild->next; | |
if (last == oldChild) | |
last = oldChild->prev; | |
if (first == oldChild) | |
first = oldChild->next; | |
oldChild->setNoParent(); | |
oldChild->next = 0; | |
oldChild->prev = 0; | |
// We are no longer interested in the old node | |
oldChild->ref.deref(); | |
return oldChild; | |
} | |
QDomNodePrivate* QDomNodePrivate::appendChild(QDomNodePrivate* newChild) | |
{ | |
// No reference manipulation needed. Done in insertAfter. | |
return insertAfter(newChild, 0); | |
} | |
QDomDocumentPrivate* QDomNodePrivate::ownerDocument() | |
{ | |
QDomNodePrivate* p = this; | |
while (p && !p->isDocument()) { | |
if (!p->hasParent) | |
return (QDomDocumentPrivate*)p->ownerNode; | |
p = p->parent(); | |
} | |
return static_cast<QDomDocumentPrivate *>(p); | |
} | |
QDomNodePrivate* QDomNodePrivate::cloneNode(bool deep) | |
{ | |
QDomNodePrivate* p = new QDomNodePrivate(this, deep); | |
// We are not interested in this node | |
p->ref.deref(); | |
return p; | |
} | |
static void qNormalizeNode(QDomNodePrivate* n) | |
{ | |
QDomNodePrivate* p = n->first; | |
QDomTextPrivate* t = 0; | |
while (p) { | |
if (p->isText()) { | |
if (t) { | |
QDomNodePrivate* tmp = p->next; | |
t->appendData(p->nodeValue()); | |
n->removeChild(p); | |
p = tmp; | |
} else { | |
t = (QDomTextPrivate*)p; | |
p = p->next; | |
} | |
} else { | |
p = p->next; | |
t = 0; | |
} | |
} | |
} | |
void QDomNodePrivate::normalize() | |
{ | |
// ### This one has moved from QDomElementPrivate to this position. It is | |
// not tested. | |
qNormalizeNode(this); | |
} | |
/*! \internal | |
\a depth is used for indentation, it seems. | |
*/ | |
void QDomNodePrivate::save(QTextStream& s, int depth, int indent) const | |
{ | |
const QDomNodePrivate* n = first; | |
while (n) { | |
n->save(s, depth, indent); | |
n = n->next; | |
} | |
} | |
void QDomNodePrivate::setLocation(int lineNumber, int columnNumber) | |
{ | |
this->lineNumber = lineNumber; | |
this->columnNumber = columnNumber; | |
} | |
/************************************************************** | |
* | |
* QDomNode | |
* | |
**************************************************************/ | |
#define IMPL ((QDomNodePrivate*)impl) | |
/*! | |
\class QDomNode | |
\reentrant | |
\brief The QDomNode class is the base class for all the nodes in a DOM tree. | |
\inmodule QtXml | |
\ingroup xml-tools | |
Many functions in the DOM return a QDomNode. | |
You can find out the type of a node using isAttr(), | |
isCDATASection(), isDocumentFragment(), isDocument(), | |
isDocumentType(), isElement(), isEntityReference(), isText(), | |
isEntity(), isNotation(), isProcessingInstruction(), | |
isCharacterData() and isComment(). | |
A QDomNode can be converted into one of its subclasses using | |
toAttr(), toCDATASection(), toDocumentFragment(), toDocument(), | |
toDocumentType(), toElement(), toEntityReference(), toText(), | |
toEntity(), toNotation(), toProcessingInstruction(), | |
toCharacterData() or toComment(). You can convert a node to a null | |
node with clear(). | |
Copies of the QDomNode class share their data using explicit | |
sharing. This means that modifying one node will change all | |
copies. This is especially useful in combination with functions | |
which return a QDomNode, e.g. firstChild(). You can make an | |
independent (deep) copy of the node with cloneNode(). | |
A QDomNode can be null, much like a null pointer. Creating a copy | |
of a null node results in another null node. It is not | |
possible to modify a null node, but it is possible to assign another, | |
possibly non-null node to it. In this case, the copy of the null node | |
will remain null. You can check if a QDomNode is null by calling isNull(). | |
The empty constructor of a QDomNode (or any of the derived classes) creates | |
a null node. | |
Nodes are inserted with insertBefore(), insertAfter() or | |
appendChild(). You can replace one node with another using | |
replaceChild() and remove a node with removeChild(). | |
To traverse nodes use firstChild() to get a node's first child (if | |
any), and nextSibling() to traverse. QDomNode also provides | |
lastChild(), previousSibling() and parentNode(). To find the first | |
child node with a particular node name use namedItem(). | |
To find out if a node has children use hasChildNodes() and to get | |
a list of all of a node's children use childNodes(). | |
The node's name and value (the meaning of which varies depending | |
on its type) is returned by nodeName() and nodeValue() | |
respectively. The node's type is returned by nodeType(). The | |
node's value can be set with setNodeValue(). | |
The document to which the node belongs is returned by | |
ownerDocument(). | |
Adjacent QDomText nodes can be merged into a single node with | |
normalize(). | |
\l QDomElement nodes have attributes which can be retrieved with | |
attributes(). | |
QDomElement and QDomAttr nodes can have namespaces which can be | |
retrieved with namespaceURI(). Their local name is retrieved with | |
localName(), and their prefix with prefix(). The prefix can be set | |
with setPrefix(). | |
You can write the XML representation of the node to a text stream | |
with save(). | |
The following example looks for the first element in an XML document and | |
prints the names of all the elements that are its direct children. | |
\snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 1 | |
For further information about the Document Object Model see | |
\l{http://www.w3.org/TR/REC-DOM-Level-1/}{Level 1} and | |
\l{http://www.w3.org/TR/DOM-Level-2-Core/}{Level 2 Core}. | |
For a more general introduction of the DOM implementation see the | |
QDomDocument documentation. | |
*/ | |
/*! | |
Constructs a \link isNull() null\endlink node. | |
*/ | |
QDomNode::QDomNode() | |
{ | |
impl = 0; | |
} | |
/*! | |
Constructs a copy of \a n. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomNode::QDomNode(const QDomNode &n) | |
{ | |
impl = n.impl; | |
if (impl) | |
impl->ref.ref(); | |
} | |
/*! \internal | |
Constructs a new node for the data \a n. | |
*/ | |
QDomNode::QDomNode(QDomNodePrivate *n) | |
{ | |
impl = n; | |
if (impl) | |
impl->ref.ref(); | |
} | |
/*! | |
Assigns a copy of \a n to this DOM node. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomNode& QDomNode::operator=(const QDomNode &n) | |
{ | |
if (n.impl) | |
n.impl->ref.ref(); | |
if (impl && !impl->ref.deref()) | |
delete impl; | |
impl = n.impl; | |
return *this; | |
} | |
/*! | |
Returns true if \a n and this DOM node are equal; otherwise | |
returns false. | |
Any instance of QDomNode acts as a reference to an underlying data | |
structure in QDomDocument. The test for equality checks if the two | |
references point to the same underlying node. For example: | |
\snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 2 | |
The two nodes (QDomElement is a QDomNode subclass) both refer to | |
the document's root element, and \c {element1 == element2} will | |
return true. On the other hand: | |
\snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 3 | |
Even though both nodes are empty elements carrying the same name, | |
\c {element3 == element4} will return false because they refer to | |
two different nodes in the underlying data structure. | |
*/ | |
bool QDomNode::operator== (const QDomNode& n) const | |
{ | |
return (impl == n.impl); | |
} | |
/*! | |
Returns true if \a n and this DOM node are not equal; otherwise | |
returns false. | |
*/ | |
bool QDomNode::operator!= (const QDomNode& n) const | |
{ | |
return (impl != n.impl); | |
} | |
/*! | |
Destroys the object and frees its resources. | |
*/ | |
QDomNode::~QDomNode() | |
{ | |
if (impl && !impl->ref.deref()) | |
delete impl; | |
} | |
/*! | |
Returns the name of the node. | |
The meaning of the name depends on the subclass: | |
\table | |
\header \i Name \i Meaning | |
\row \i QDomAttr \i The name of the attribute | |
\row \i QDomCDATASection \i The string "#cdata-section" | |
\row \i QDomComment \i The string "#comment" | |
\row \i QDomDocument \i The string "#document" | |
\row \i QDomDocumentFragment \i The string "#document-fragment" | |
\row \i QDomDocumentType \i The name of the document type | |
\row \i QDomElement \i The tag name | |
\row \i QDomEntity \i The name of the entity | |
\row \i QDomEntityReference \i The name of the referenced entity | |
\row \i QDomNotation \i The name of the notation | |
\row \i QDomProcessingInstruction \i The target of the processing instruction | |
\row \i QDomText \i The string "#text" | |
\endtable | |
\bold{Note:} This function does not take the presence of namespaces into account | |
when processing the names of element and attribute nodes. As a result, the | |
returned name can contain any namespace prefix that may be present. | |
To obtain the node name of an element or attribute, use localName(); to | |
obtain the namespace prefix, use namespaceURI(). | |
\sa nodeValue() | |
*/ | |
QString QDomNode::nodeName() const | |
{ | |
if (!impl) | |
return QString(); | |
if (!IMPL->prefix.isEmpty()) | |
return IMPL->prefix + QLatin1Char(':') + IMPL->name; | |
return IMPL->name; | |
} | |
/*! | |
Returns the value of the node. | |
The meaning of the value depends on the subclass: | |
\table | |
\header \i Name \i Meaning | |
\row \i QDomAttr \i The attribute value | |
\row \i QDomCDATASection \i The content of the CDATA section | |
\row \i QDomComment \i The comment | |
\row \i QDomProcessingInstruction \i The data of the processing instruction | |
\row \i QDomText \i The text | |
\endtable | |
All the other subclasses do not have a node value and will return | |
an empty string. | |
\sa setNodeValue() nodeName() | |
*/ | |
QString QDomNode::nodeValue() const | |
{ | |
if (!impl) | |
return QString(); | |
return IMPL->value; | |
} | |
/*! | |
Sets the node's value to \a v. | |
\sa nodeValue() | |
*/ | |
void QDomNode::setNodeValue(const QString& v) | |
{ | |
if (!impl) | |
return; | |
IMPL->setNodeValue(v); | |
} | |
/*! | |
\enum QDomNode::NodeType | |
This enum defines the type of the node: | |
\value ElementNode | |
\value AttributeNode | |
\value TextNode | |
\value CDATASectionNode | |
\value EntityReferenceNode | |
\value EntityNode | |
\value ProcessingInstructionNode | |
\value CommentNode | |
\value DocumentNode | |
\value DocumentTypeNode | |
\value DocumentFragmentNode | |
\value NotationNode | |
\value BaseNode A QDomNode object, i.e. not a QDomNode subclass. | |
\value CharacterDataNode | |
*/ | |
/*! | |
Returns the type of the node. | |
\sa toAttr(), toCDATASection(), toDocumentFragment(), | |
toDocument() toDocumentType(), toElement(), toEntityReference(), | |
toText(), toEntity() toNotation(), toProcessingInstruction(), | |
toCharacterData(), toComment() | |
*/ | |
QDomNode::NodeType QDomNode::nodeType() const | |
{ | |
if (!impl) | |
return QDomNode::BaseNode; | |
return IMPL->nodeType(); | |
} | |
/*! | |
Returns the parent node. If this node has no parent, a null node | |
is returned (i.e. a node for which isNull() returns true). | |
*/ | |
QDomNode QDomNode::parentNode() const | |
{ | |
if (!impl) | |
return QDomNode(); | |
return QDomNode(IMPL->parent()); | |
} | |
/*! | |
Returns a list of all direct child nodes. | |
Most often you will call this function on a QDomElement object. | |
For example, if the XML document looks like this: | |
\snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 4 | |
Then the list of child nodes for the "body"-element will contain | |
the node created by the <h1> tag and the node created by the | |
<p> tag. | |
The nodes in the list are not copied; so changing the nodes in the | |
list will also change the children of this node. | |
\sa firstChild() lastChild() | |
*/ | |
QDomNodeList QDomNode::childNodes() const | |
{ | |
if (!impl) | |
return QDomNodeList(); | |
return QDomNodeList(new QDomNodeListPrivate(impl)); | |
} | |
/*! | |
Returns the first child of the node. If there is no child node, a | |
\link isNull() null node\endlink is returned. Changing the | |
returned node will also change the node in the document tree. | |
\sa lastChild() childNodes() | |
*/ | |
QDomNode QDomNode::firstChild() const | |
{ | |
if (!impl) | |
return QDomNode(); | |
return QDomNode(IMPL->first); | |
} | |
/*! | |
Returns the last child of the node. If there is no child node, a | |
\link isNull() null node\endlink is returned. Changing the | |
returned node will also change the node in the document tree. | |
\sa firstChild() childNodes() | |
*/ | |
QDomNode QDomNode::lastChild() const | |
{ | |
if (!impl) | |
return QDomNode(); | |
return QDomNode(IMPL->last); | |
} | |
/*! | |
Returns the previous sibling in the document tree. Changing the | |
returned node will also change the node in the document tree. | |
For example, if you have XML like this: | |
\snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 5 | |
and this QDomNode represents the <p> tag, previousSibling() | |
will return the node representing the <h1> tag. | |
\sa nextSibling() | |
*/ | |
QDomNode QDomNode::previousSibling() const | |
{ | |
if (!impl) | |
return QDomNode(); | |
return QDomNode(IMPL->prev); | |
} | |
/*! | |
Returns the next sibling in the document tree. Changing the | |
returned node will also change the node in the document tree. | |
If you have XML like this: | |
\snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 6 | |
and this QDomNode represents the <p> tag, nextSibling() will | |
return the node representing the <h2> tag. | |
\sa previousSibling() | |
*/ | |
QDomNode QDomNode::nextSibling() const | |
{ | |
if (!impl) | |
return QDomNode(); | |
return QDomNode(IMPL->next); | |
} | |
// ###### don't think this is part of the DOM and | |
/*! | |
Returns a named node map of all attributes. Attributes are only | |
provided for \l{QDomElement}s. | |
Changing the attributes in the map will also change the attributes | |
of this QDomNode. | |
*/ | |
QDomNamedNodeMap QDomNode::attributes() const | |
{ | |
if (!impl || !impl->isElement()) | |
return QDomNamedNodeMap(); | |
return QDomNamedNodeMap(static_cast<QDomElementPrivate *>(impl)->attributes()); | |
} | |
/*! | |
Returns the document to which this node belongs. | |
*/ | |
QDomDocument QDomNode::ownerDocument() const | |
{ | |
if (!impl) | |
return QDomDocument(); | |
return QDomDocument(IMPL->ownerDocument()); | |
} | |
/*! | |
Creates a deep (not shallow) copy of the QDomNode. | |
If \a deep is true, then the cloning is done recursively which | |
means that all the node's children are deep copied too. If \a deep | |
is false only the node itself is copied and the copy will have no | |
child nodes. | |
*/ | |
QDomNode QDomNode::cloneNode(bool deep) const | |
{ | |
if (!impl) | |
return QDomNode(); | |
return QDomNode(IMPL->cloneNode(deep)); | |
} | |
/*! | |
Calling normalize() on an element converts all its children into a | |
standard form. This means that adjacent QDomText objects will be | |
merged into a single text object (QDomCDATASection nodes are not | |
merged). | |
*/ | |
void QDomNode::normalize() | |
{ | |
if (!impl) | |
return; | |
IMPL->normalize(); | |
} | |
/*! | |
Returns true if the DOM implementation implements the feature \a | |
feature and this feature is supported by this node in the version | |
\a version; otherwise returns false. | |
\sa QDomImplementation::hasFeature() | |
*/ | |
bool QDomNode::isSupported(const QString& feature, const QString& version) const | |
{ | |
QDomImplementation i; | |
return i.hasFeature(feature, version); | |
} | |
/*! | |
Returns the namespace URI of this node or an empty string if the | |
node has no namespace URI. | |
Only nodes of type \link QDomNode::NodeType ElementNode\endlink or | |
\link QDomNode::NodeType AttributeNode\endlink can have | |
namespaces. A namespace URI must be specified at creation time and | |
cannot be changed later. | |
\sa prefix() localName() QDomDocument::createElementNS() | |
QDomDocument::createAttributeNS() | |
*/ | |
QString QDomNode::namespaceURI() const | |
{ | |
if (!impl) | |
return QString(); | |
return IMPL->namespaceURI; | |
} | |
/*! | |
Returns the namespace prefix of the node or an empty string if the | |
node has no namespace prefix. | |
Only nodes of type \link QDomNode::NodeType ElementNode\endlink or | |
\link QDomNode::NodeType AttributeNode\endlink can have | |
namespaces. A namespace prefix must be specified at creation time. | |
If a node was created with a namespace prefix, you can change it | |
later with setPrefix(). | |
If you create an element or attribute with | |
QDomDocument::createElement() or QDomDocument::createAttribute(), | |
the prefix will be an empty string. If you use | |
QDomDocument::createElementNS() or | |
QDomDocument::createAttributeNS() instead, the prefix will not be | |
an empty string; but it might be an empty string if the name does | |
not have a prefix. | |
\sa setPrefix() localName() namespaceURI() | |
QDomDocument::createElementNS() QDomDocument::createAttributeNS() | |
*/ | |
QString QDomNode::prefix() const | |
{ | |
if (!impl) | |
return QString(); | |
return IMPL->prefix; | |
} | |
/*! | |
If the node has a namespace prefix, this function changes the | |
namespace prefix of the node to \a pre. Otherwise this function | |
does nothing. | |
Only nodes of type \link QDomNode::NodeType ElementNode\endlink or | |
\link QDomNode::NodeType AttributeNode\endlink can have | |
namespaces. A namespace prefix must have be specified at creation | |
time; it is not possible to add a namespace prefix afterwards. | |
\sa prefix() localName() namespaceURI() | |
QDomDocument::createElementNS() QDomDocument::createAttributeNS() | |
*/ | |
void QDomNode::setPrefix(const QString& pre) | |
{ | |
if (!impl || IMPL->prefix.isNull()) | |
return; | |
if (isAttr() || isElement()) | |
IMPL->prefix = pre; | |
} | |
/*! | |
If the node uses namespaces, this function returns the local name | |
of the node; otherwise it returns an empty string. | |
Only nodes of type \link QDomNode::NodeType ElementNode\endlink or | |
\link QDomNode::NodeType AttributeNode\endlink can have | |
namespaces. A namespace must have been specified at creation time; | |
it is not possible to add a namespace afterwards. | |
\sa prefix() namespaceURI() QDomDocument::createElementNS() | |
QDomDocument::createAttributeNS() | |
*/ | |
QString QDomNode::localName() const | |
{ | |
if (!impl || IMPL->createdWithDom1Interface) | |
return QString(); | |
return IMPL->name; | |
} | |
/*! | |
Returns true if the node has attributes; otherwise returns false. | |
\sa attributes() | |
*/ | |
bool QDomNode::hasAttributes() const | |
{ | |
if (!impl || !impl->isElement()) | |
return false; | |
return static_cast<QDomElementPrivate *>(impl)->hasAttributes(); | |
} | |
/*! | |
Inserts the node \a newChild before the child node \a refChild. | |
\a refChild must be a direct child of this node. If \a refChild is | |
\link isNull() null\endlink then \a newChild is inserted as the | |
node's first child. | |
If \a newChild is the child of another node, it is reparented to | |
this node. If \a newChild is a child of this node, then its | |
position in the list of children is changed. | |
If \a newChild is a QDomDocumentFragment, then the children of the | |
fragment are removed from the fragment and inserted before \a | |
refChild. | |
Returns a new reference to \a newChild on success or a \link | |
isNull() null node\endlink on failure. | |
The DOM specification disallow inserting attribute nodes, but due | |
to historical reasons QDom accept them nevertheless. | |
\sa insertAfter() replaceChild() removeChild() appendChild() | |
*/ | |
QDomNode QDomNode::insertBefore(const QDomNode& newChild, const QDomNode& refChild) | |
{ | |
if (!impl) | |
return QDomNode(); | |
return QDomNode(IMPL->insertBefore(newChild.impl, refChild.impl)); | |
} | |
/*! | |
Inserts the node \a newChild after the child node \a refChild. \a | |
refChild must be a direct child of this node. If \a refChild is | |
\link isNull() null\endlink then \a newChild is appended as this | |
node's last child. | |
If \a newChild is the child of another node, it is reparented to | |
this node. If \a newChild is a child of this node, then its | |
position in the list of children is changed. | |
If \a newChild is a QDomDocumentFragment, then the children of the | |
fragment are removed from the fragment and inserted after \a | |
refChild. | |
Returns a new reference to \a newChild on success or a \link | |
isNull() null node\endlink on failure. | |
The DOM specification disallow inserting attribute nodes, but due | |
to historical reasons QDom accept them nevertheless. | |
\sa insertBefore() replaceChild() removeChild() appendChild() | |
*/ | |
QDomNode QDomNode::insertAfter(const QDomNode& newChild, const QDomNode& refChild) | |
{ | |
if (!impl) | |
return QDomNode(); | |
return QDomNode(IMPL->insertAfter(newChild.impl, refChild.impl)); | |
} | |
/*! | |
Replaces \a oldChild with \a newChild. \a oldChild must be a | |
direct child of this node. | |
If \a newChild is the child of another node, it is reparented to | |
this node. If \a newChild is a child of this node, then its | |
position in the list of children is changed. | |
If \a newChild is a QDomDocumentFragment, then \a oldChild is | |
replaced by all of the children of the fragment. | |
Returns a new reference to \a oldChild on success or a \link | |
isNull() null node\endlink an failure. | |
\sa insertBefore() insertAfter() removeChild() appendChild() | |
*/ | |
QDomNode QDomNode::replaceChild(const QDomNode& newChild, const QDomNode& oldChild) | |
{ | |
if (!impl || !newChild.impl || !oldChild.impl) | |
return QDomNode(); | |
return QDomNode(IMPL->replaceChild(newChild.impl, oldChild.impl)); | |
} | |
/*! | |
Removes \a oldChild from the list of children. \a oldChild must be | |
a direct child of this node. | |
Returns a new reference to \a oldChild on success or a \link | |
isNull() null node\endlink on failure. | |
\sa insertBefore() insertAfter() replaceChild() appendChild() | |
*/ | |
QDomNode QDomNode::removeChild(const QDomNode& oldChild) | |
{ | |
if (!impl) | |
return QDomNode(); | |
if (oldChild.isNull()) | |
return QDomNode(); | |
return QDomNode(IMPL->removeChild(oldChild.impl)); | |
} | |
/*! | |
Appends \a newChild as the node's last child. | |
If \a newChild is the child of another node, it is reparented to | |
this node. If \a newChild is a child of this node, then its | |
position in the list of children is changed. | |
If \a newChild is a QDomDocumentFragment, then the children of the | |
fragment are removed from the fragment and appended. | |
If \a newChild is a QDomElement and this node is a QDomDocument that | |
already has an element node as a child, \a newChild is not added as | |
a child and a null node is returned. | |
Returns a new reference to \a newChild on success or a \link | |
isNull() null node\endlink on failure. | |
Calling this function on a null node(created, for example, with | |
the default constructor) does nothing and returns a \link isNull() | |
null node\endlink. | |
The DOM specification disallow inserting attribute nodes, but for | |
historical reasons, QDom accepts them anyway. | |
\sa insertBefore() insertAfter() replaceChild() removeChild() | |
*/ | |
QDomNode QDomNode::appendChild(const QDomNode& newChild) | |
{ | |
if (!impl) { | |
qWarning("Calling appendChild() on a null node does nothing."); | |
return QDomNode(); | |
} | |
return QDomNode(IMPL->appendChild(newChild.impl)); | |
} | |
/*! | |
Returns true if the node has one or more children; otherwise | |
returns false. | |
*/ | |
bool QDomNode::hasChildNodes() const | |
{ | |
if (!impl) | |
return false; | |
return IMPL->first != 0; | |
} | |
/*! | |
Returns true if this node is null (i.e. if it has no type or | |
contents); otherwise returns false. | |
*/ | |
bool QDomNode::isNull() const | |
{ | |
return (impl == 0); | |
} | |
/*! | |
Converts the node into a null node; if it was not a null node | |
before, its type and contents are deleted. | |
\sa isNull() | |
*/ | |
void QDomNode::clear() | |
{ | |
if (impl && !impl->ref.deref()) | |
delete impl; | |
impl = 0; | |
} | |
/*! | |
Returns the first direct child node for which nodeName() equals \a | |
name. | |
If no such direct child exists, a \link isNull() null node\endlink | |
is returned. | |
\sa nodeName() | |
*/ | |
QDomNode QDomNode::namedItem(const QString& name) const | |
{ | |
if (!impl) | |
return QDomNode(); | |
return QDomNode(impl->namedItem(name)); | |
} | |
/*! | |
Writes the XML representation of the node and all its children to | |
the stream \a str. This function uses \a indent as the amount of | |
space to indent the node. | |
If this node is a document node, the encoding of text stream \a str's encoding is | |
set by treating a processing instruction by name "xml" as an XML declaration, if such a one exists, | |
and otherwise defaults to UTF-8. XML declarations are not processing instructions, but this | |
behavior exists for historical reasons. If this node is not a document node, | |
the text stream's encoding is used. | |
If the document contains invalid XML characters or characters that cannot be | |
encoded in the given encoding, the result and behavior is undefined. | |
*/ | |
void QDomNode::save(QTextStream& str, int indent) const | |
{ | |
save(str, indent, QDomNode::EncodingFromDocument); | |
} | |
/*! | |
If \a encodingPolicy is QDomNode::EncodingFromDocument, this function behaves as save(QTextStream &str, int indent). | |
If \a encodingPolicy is EncodingFromTextStream and this node is a document node, this | |
function behaves as save(QTextStream &str, int indent) with the exception that the encoding | |
specified in the text stream \a str is used. | |
If the document contains invalid XML characters or characters that cannot be | |
encoded in the given encoding, the result and behavior is undefined. | |
\since 4.2 | |
*/ | |
void QDomNode::save(QTextStream& str, int indent, EncodingPolicy encodingPolicy) const | |
{ | |
if (!impl) | |
return; | |
if(isDocument()) | |
static_cast<const QDomDocumentPrivate *>(impl)->saveDocument(str, indent, encodingPolicy); | |
else | |
IMPL->save(str, 1, indent); | |
} | |
/*! | |
\relates QDomNode | |
Writes the XML representation of the node \a node and all its | |
children to the stream \a str. | |
*/ | |
QTextStream& operator<<(QTextStream& str, const QDomNode& node) | |
{ | |
node.save(str, 1); | |
return str; | |
} | |
/*! | |
Returns true if the node is an attribute; otherwise returns false. | |
If this function returns true, it does not imply that this object | |
is a QDomAttribute; you can get the QDomAttribute with | |
toAttribute(). | |
\sa toAttr() | |
*/ | |
bool QDomNode::isAttr() const | |
{ | |
if(impl) | |
return impl->isAttr(); | |
return false; | |
} | |
/*! | |
Returns true if the node is a CDATA section; otherwise returns | |
false. | |
If this function returns true, it does not imply that this object | |
is a QDomCDATASection; you can get the QDomCDATASection with | |
toCDATASection(). | |
\sa toCDATASection() | |
*/ | |
bool QDomNode::isCDATASection() const | |
{ | |
if(impl) | |
return impl->isCDATASection(); | |
return false; | |
} | |
/*! | |
Returns true if the node is a document fragment; otherwise returns | |
false. | |
If this function returns true, it does not imply that this object | |
is a QDomDocumentFragment; you can get the QDomDocumentFragment | |
with toDocumentFragment(). | |
\sa toDocumentFragment() | |
*/ | |
bool QDomNode::isDocumentFragment() const | |
{ | |
if(impl) | |
return impl->isDocumentFragment(); | |
return false; | |
} | |
/*! | |
Returns true if the node is a document; otherwise returns false. | |
If this function returns true, it does not imply that this object | |
is a QDomDocument; you can get the QDomDocument with toDocument(). | |
\sa toDocument() | |
*/ | |
bool QDomNode::isDocument() const | |
{ | |
if(impl) | |
return impl->isDocument(); | |
return false; | |
} | |
/*! | |
Returns true if the node is a document type; otherwise returns | |
false. | |
If this function returns true, it does not imply that this object | |
is a QDomDocumentType; you can get the QDomDocumentType with | |
toDocumentType(). | |
\sa toDocumentType() | |
*/ | |
bool QDomNode::isDocumentType() const | |
{ | |
if(impl) | |
return impl->isDocumentType(); | |
return false; | |
} | |
/*! | |
Returns true if the node is an element; otherwise returns false. | |
If this function returns true, it does not imply that this object | |
is a QDomElement; you can get the QDomElement with toElement(). | |
\sa toElement() | |
*/ | |
bool QDomNode::isElement() const | |
{ | |
if(impl) | |
return impl->isElement(); | |
return false; | |
} | |
/*! | |
Returns true if the node is an entity reference; otherwise returns | |
false. | |
If this function returns true, it does not imply that this object | |
is a QDomEntityReference; you can get the QDomEntityReference with | |
toEntityReference(). | |
\sa toEntityReference() | |
*/ | |
bool QDomNode::isEntityReference() const | |
{ | |
if(impl) | |
return impl->isEntityReference(); | |
return false; | |
} | |
/*! | |
Returns true if the node is a text node; otherwise returns false. | |
If this function returns true, it does not imply that this object | |
is a QDomText; you can get the QDomText with toText(). | |
\sa toText() | |
*/ | |
bool QDomNode::isText() const | |
{ | |
if(impl) | |
return impl->isText(); | |
return false; | |
} | |
/*! | |
Returns true if the node is an entity; otherwise returns false. | |
If this function returns true, it does not imply that this object | |
is a QDomEntity; you can get the QDomEntity with toEntity(). | |
\sa toEntity() | |
*/ | |
bool QDomNode::isEntity() const | |
{ | |
if(impl) | |
return impl->isEntity(); | |
return false; | |
} | |
/*! | |
Returns true if the node is a notation; otherwise returns false. | |
If this function returns true, it does not imply that this object | |
is a QDomNotation; you can get the QDomNotation with toNotation(). | |
\sa toNotation() | |
*/ | |
bool QDomNode::isNotation() const | |
{ | |
if(impl) | |
return impl->isNotation(); | |
return false; | |
} | |
/*! | |
Returns true if the node is a processing instruction; otherwise | |
returns false. | |
If this function returns true, it does not imply that this object | |
is a QDomProcessingInstruction; you can get the | |
QProcessingInstruction with toProcessingInstruction(). | |
\sa toProcessingInstruction() | |
*/ | |
bool QDomNode::isProcessingInstruction() const | |
{ | |
if(impl) | |
return impl->isProcessingInstruction(); | |
return false; | |
} | |
/*! | |
Returns true if the node is a character data node; otherwise | |
returns false. | |
If this function returns true, it does not imply that this object | |
is a QDomCharacterData; you can get the QDomCharacterData with | |
toCharacterData(). | |
\sa toCharacterData() | |
*/ | |
bool QDomNode::isCharacterData() const | |
{ | |
if (impl) | |
return impl->isCharacterData(); | |
return false; | |
} | |
/*! | |
Returns true if the node is a comment; otherwise returns false. | |
If this function returns true, it does not imply that this object | |
is a QDomComment; you can get the QDomComment with toComment(). | |
\sa toComment() | |
*/ | |
bool QDomNode::isComment() const | |
{ | |
if (impl) | |
return impl->isComment(); | |
return false; | |
} | |
#undef IMPL | |
/*! | |
Returns the first child element with tag name \a tagName if tagName is non-empty; | |
otherwise returns the first child element. Returns a null element if no | |
such child exists. | |
\sa lastChildElement() previousSiblingElement() nextSiblingElement() | |
*/ | |
QDomElement QDomNode::firstChildElement(const QString &tagName) const | |
{ | |
for (QDomNode child = firstChild(); !child.isNull(); child = child.nextSibling()) { | |
if (child.isElement()) { | |
QDomElement elt = child.toElement(); | |
if (tagName.isEmpty() || elt.tagName() == tagName) | |
return elt; | |
} | |
} | |
return QDomElement(); | |
} | |
/*! | |
Returns the last child element with tag name \a tagName if tagName is non-empty; | |
otherwise returns the first child element. Returns a null element if no | |
such child exists. | |
\sa firstChildElement() previousSiblingElement() nextSiblingElement() | |
*/ | |
QDomElement QDomNode::lastChildElement(const QString &tagName) const | |
{ | |
for (QDomNode child = lastChild(); !child.isNull(); child = child.previousSibling()) { | |
if (child.isElement()) { | |
QDomElement elt = child.toElement(); | |
if (tagName.isEmpty() || elt.tagName() == tagName) | |
return elt; | |
} | |
} | |
return QDomElement(); | |
} | |
/*! | |
Returns the next sibling element with tag name \a tagName if \a tagName | |
is non-empty; otherwise returns any next sibling element. | |
Returns a null element if no such sibling exists. | |
\sa firstChildElement() previousSiblingElement() lastChildElement() | |
*/ | |
QDomElement QDomNode::nextSiblingElement(const QString &tagName) const | |
{ | |
for (QDomNode sib = nextSibling(); !sib.isNull(); sib = sib.nextSibling()) { | |
if (sib.isElement()) { | |
QDomElement elt = sib.toElement(); | |
if (tagName.isEmpty() || elt.tagName() == tagName) | |
return elt; | |
} | |
} | |
return QDomElement(); | |
} | |
/*! | |
Returns the previous sibilng element with tag name \a tagName if \a tagName | |
is non-empty; otherwise returns any previous sibling element. | |
Returns a null element if no such sibling exists. | |
\sa firstChildElement(), nextSiblingElement(), lastChildElement() | |
*/ | |
QDomElement QDomNode::previousSiblingElement(const QString &tagName) const | |
{ | |
for (QDomNode sib = previousSibling(); !sib.isNull(); sib = sib.previousSibling()) { | |
if (sib.isElement()) { | |
QDomElement elt = sib.toElement(); | |
if (tagName.isEmpty() || elt.tagName() == tagName) | |
return elt; | |
} | |
} | |
return QDomElement(); | |
} | |
/*! | |
\since 4.1 | |
For nodes created by QDomDocument::setContent(), this function | |
returns the line number in the XML document where the node was parsed. | |
Otherwise, -1 is returned. | |
\sa columnNumber(), QDomDocument::setContent() | |
*/ | |
int QDomNode::lineNumber() const | |
{ | |
return impl ? impl->lineNumber : -1; | |
} | |
/*! | |
\since 4.1 | |
For nodes created by QDomDocument::setContent(), this function | |
returns the column number in the XML document where the node was parsed. | |
Otherwise, -1 is returned. | |
\sa lineNumber(), QDomDocument::setContent() | |
*/ | |
int QDomNode::columnNumber() const | |
{ | |
return impl ? impl->columnNumber : -1; | |
} | |
/************************************************************** | |
* | |
* QDomNamedNodeMapPrivate | |
* | |
**************************************************************/ | |
QDomNamedNodeMapPrivate::QDomNamedNodeMapPrivate(QDomNodePrivate* n) | |
{ | |
ref = 1; | |
readonly = false; | |
parent = n; | |
appendToParent = false; | |
} | |
QDomNamedNodeMapPrivate::~QDomNamedNodeMapPrivate() | |
{ | |
clearMap(); | |
} | |
QDomNamedNodeMapPrivate* QDomNamedNodeMapPrivate::clone(QDomNodePrivate* p) | |
{ | |
QScopedPointer<QDomNamedNodeMapPrivate> m(new QDomNamedNodeMapPrivate(p)); | |
m->readonly = readonly; | |
m->appendToParent = appendToParent; | |
QHash<QString, QDomNodePrivate*>::const_iterator it = map.constBegin(); | |
for (; it != map.constEnd(); ++it) { | |
QDomNodePrivate *new_node = (*it)->cloneNode(); | |
new_node->setParent(p); | |
m->setNamedItem(new_node); | |
} | |
// we are no longer interested in ownership | |
m->ref.deref(); | |
return m.take(); | |
} | |
void QDomNamedNodeMapPrivate::clearMap() | |
{ | |
// Dereference all of our children if we took references | |
if (!appendToParent) { | |
QHash<QString, QDomNodePrivate *>::const_iterator it = map.constBegin(); | |
for (; it != map.constEnd(); ++it) | |
if (!(*it)->ref.deref()) | |
delete *it; | |
} | |
map.clear(); | |
} | |
QDomNodePrivate* QDomNamedNodeMapPrivate::namedItem(const QString& name) const | |
{ | |
QDomNodePrivate* p = map[name]; | |
return p; | |
} | |
QDomNodePrivate* QDomNamedNodeMapPrivate::namedItemNS(const QString& nsURI, const QString& localName) const | |
{ | |
QHash<QString, QDomNodePrivate *>::const_iterator it = map.constBegin(); | |
QDomNodePrivate *n; | |
for (; it != map.constEnd(); ++it) { | |
n = *it; | |
if (!n->prefix.isNull()) { | |
// node has a namespace | |
if (n->namespaceURI == nsURI && n->name == localName) | |
return n; | |
} | |
} | |
return 0; | |
} | |
QDomNodePrivate* QDomNamedNodeMapPrivate::setNamedItem(QDomNodePrivate* arg) | |
{ | |
if (readonly || !arg) | |
return 0; | |
if (appendToParent) | |
return parent->appendChild(arg); | |
QDomNodePrivate *n = map.value(arg->nodeName()); | |
// We take a reference | |
arg->ref.ref(); | |
map.insertMulti(arg->nodeName(), arg); | |
return n; | |
} | |
QDomNodePrivate* QDomNamedNodeMapPrivate::setNamedItemNS(QDomNodePrivate* arg) | |
{ | |
if (readonly || !arg) | |
return 0; | |
if (appendToParent) | |
return parent->appendChild(arg); | |
if (!arg->prefix.isNull()) { | |
// node has a namespace | |
QDomNodePrivate *n = namedItemNS(arg->namespaceURI, arg->name); | |
// We take a reference | |
arg->ref.ref(); | |
map.insertMulti(arg->nodeName(), arg); | |
return n; | |
} else { | |
// ### check the following code if it is ok | |
return setNamedItem(arg); | |
} | |
} | |
QDomNodePrivate* QDomNamedNodeMapPrivate::removeNamedItem(const QString& name) | |
{ | |
if (readonly) | |
return 0; | |
QDomNodePrivate* p = namedItem(name); | |
if (p == 0) | |
return 0; | |
if (appendToParent) | |
return parent->removeChild(p); | |
map.remove(p->nodeName()); | |
// We took a reference, so we have to free one here | |
p->ref.deref(); | |
return p; | |
} | |
QDomNodePrivate* QDomNamedNodeMapPrivate::item(int index) const | |
{ | |
if ((uint)index >= length()) | |
return 0; | |
return *(map.constBegin() + index); | |
} | |
// ### Qt 5: convert all length/size() functions in QDom to use int instead of uint. | |
uint QDomNamedNodeMapPrivate::length() const | |
{ | |
return map.count(); | |
} | |
bool QDomNamedNodeMapPrivate::contains(const QString& name) const | |
{ | |
return map.value(name) != 0; | |
} | |
bool QDomNamedNodeMapPrivate::containsNS(const QString& nsURI, const QString & localName) const | |
{ | |
return namedItemNS(nsURI, localName) != 0; | |
} | |
/************************************************************** | |
* | |
* QDomNamedNodeMap | |
* | |
**************************************************************/ | |
#define IMPL ((QDomNamedNodeMapPrivate*)impl) | |
/*! | |
\class QDomNamedNodeMap | |
\reentrant | |
\brief The QDomNamedNodeMap class contains a collection of nodes | |
that can be accessed by name. | |
\inmodule QtXml | |
\ingroup xml-tools | |
Note that QDomNamedNodeMap does not inherit from QDomNodeList. | |
QDomNamedNodeMaps do not provide any specific node ordering. | |
Although nodes in a QDomNamedNodeMap may be accessed by an ordinal | |
index, this is simply to allow a convenient enumeration of the | |
contents of a QDomNamedNodeMap, and does not imply that the DOM | |
specifies an ordering of the nodes. | |
The QDomNamedNodeMap is used in three places: | |
\list 1 | |
\i QDomDocumentType::entities() returns a map of all entities | |
described in the DTD. | |
\i QDomDocumentType::notations() returns a map of all notations | |
described in the DTD. | |
\i QDomNode::attributes() returns a map of all attributes of an | |
element. | |
\endlist | |
Items in the map are identified by the name which QDomNode::name() | |
returns. Nodes are retrieved using namedItem(), namedItemNS() or | |
item(). New nodes are inserted with setNamedItem() or | |
setNamedItemNS() and removed with removeNamedItem() or | |
removeNamedItemNS(). Use contains() to see if an item with the | |
given name is in the named node map. The number of items is | |
returned by length(). | |
Terminology: in this class we use "item" and "node" | |
interchangeably. | |
*/ | |
/*! | |
Constructs an empty named node map. | |
*/ | |
QDomNamedNodeMap::QDomNamedNodeMap() | |
{ | |
impl = 0; | |
} | |
/*! | |
Constructs a copy of \a n. | |
*/ | |
QDomNamedNodeMap::QDomNamedNodeMap(const QDomNamedNodeMap &n) | |
{ | |
impl = n.impl; | |
if (impl) | |
impl->ref.ref(); | |
} | |
QDomNamedNodeMap::QDomNamedNodeMap(QDomNamedNodeMapPrivate *n) | |
{ | |
impl = n; | |
if (impl) | |
impl->ref.ref(); | |
} | |
/*! | |
Assigns \a n to this named node map. | |
*/ | |
QDomNamedNodeMap& QDomNamedNodeMap::operator=(const QDomNamedNodeMap &n) | |
{ | |
if (n.impl) | |
n.impl->ref.ref(); | |
if (impl && !impl->ref.deref()) | |
delete impl; | |
impl = n.impl; | |
return *this; | |
} | |
/*! | |
Returns true if \a n and this named node map are equal; otherwise | |
returns false. | |
*/ | |
bool QDomNamedNodeMap::operator== (const QDomNamedNodeMap& n) const | |
{ | |
return (impl == n.impl); | |
} | |
/*! | |
Returns true if \a n and this named node map are not equal; | |
otherwise returns false. | |
*/ | |
bool QDomNamedNodeMap::operator!= (const QDomNamedNodeMap& n) const | |
{ | |
return (impl != n.impl); | |
} | |
/*! | |
Destroys the object and frees its resources. | |
*/ | |
QDomNamedNodeMap::~QDomNamedNodeMap() | |
{ | |
if (impl && !impl->ref.deref()) | |
delete impl; | |
} | |
/*! | |
Returns the node called \a name. | |
If the named node map does not contain such a node, a \link | |
QDomNode::isNull() null node\endlink is returned. A node's name is | |
the name returned by QDomNode::nodeName(). | |
\sa setNamedItem() namedItemNS() | |
*/ | |
QDomNode QDomNamedNodeMap::namedItem(const QString& name) const | |
{ | |
if (!impl) | |
return QDomNode(); | |
return QDomNode(IMPL->namedItem(name)); | |
} | |
/*! | |
Inserts the node \a newNode into the named node map. The name used | |
by the map is the node name of \a newNode as returned by | |
QDomNode::nodeName(). | |
If the new node replaces an existing node, i.e. the map contains a | |
node with the same name, the replaced node is returned. | |
\sa namedItem() removeNamedItem() setNamedItemNS() | |
*/ | |
QDomNode QDomNamedNodeMap::setNamedItem(const QDomNode& newNode) | |
{ | |
if (!impl) | |
return QDomNode(); | |
return QDomNode(IMPL->setNamedItem((QDomNodePrivate*)newNode.impl)); | |
} | |
/*! | |
Removes the node called \a name from the map. | |
The function returns the removed node or a \link | |
QDomNode::isNull() null node\endlink if the map did not contain a | |
node called \a name. | |
\sa setNamedItem() namedItem() removeNamedItemNS() | |
*/ | |
QDomNode QDomNamedNodeMap::removeNamedItem(const QString& name) | |
{ | |
if (!impl) | |
return QDomNode(); | |
return QDomNode(IMPL->removeNamedItem(name)); | |
} | |
/*! | |
Retrieves the node at position \a index. | |
This can be used to iterate over the map. Note that the nodes in | |
the map are ordered arbitrarily. | |
\sa length() | |
*/ | |
QDomNode QDomNamedNodeMap::item(int index) const | |
{ | |
if (!impl) | |
return QDomNode(); | |
return QDomNode(IMPL->item(index)); | |
} | |
/*! | |
Returns the node associated with the local name \a localName and | |
the namespace URI \a nsURI. | |
If the map does not contain such a node, a \link | |
QDomNode::isNull() null node\endlink is returned. | |
\sa setNamedItemNS() namedItem() | |
*/ | |
QDomNode QDomNamedNodeMap::namedItemNS(const QString& nsURI, const QString& localName) const | |
{ | |
if (!impl) | |
return QDomNode(); | |
return QDomNode(IMPL->namedItemNS(nsURI, localName)); | |
} | |
/*! | |
Inserts the node \a newNode in the map. If a node with the same | |
namespace URI and the same local name already exists in the map, | |
it is replaced by \a newNode. If the new node replaces an existing | |
node, the replaced node is returned. | |
\sa namedItemNS() removeNamedItemNS() setNamedItem() | |
*/ | |
QDomNode QDomNamedNodeMap::setNamedItemNS(const QDomNode& newNode) | |
{ | |
if (!impl) | |
return QDomNode(); | |
return QDomNode(IMPL->setNamedItemNS((QDomNodePrivate*)newNode.impl)); | |
} | |
/*! | |
Removes the node with the local name \a localName and the | |
namespace URI \a nsURI from the map. | |
The function returns the removed node or a \link | |
QDomNode::isNull() null node\endlink if the map did not contain a | |
node with the local name \a localName and the namespace URI \a | |
nsURI. | |
\sa setNamedItemNS() namedItemNS() removeNamedItem() | |
*/ | |
QDomNode QDomNamedNodeMap::removeNamedItemNS(const QString& nsURI, const QString& localName) | |
{ | |
if (!impl) | |
return QDomNode(); | |
QDomNodePrivate *n = IMPL->namedItemNS(nsURI, localName); | |
if (!n) | |
return QDomNode(); | |
return QDomNode(IMPL->removeNamedItem(n->name)); | |
} | |
/*! | |
Returns the number of nodes in the map. | |
\sa item() | |
*/ | |
uint QDomNamedNodeMap::length() const | |
{ | |
if (!impl) | |
return 0; | |
return IMPL->length(); | |
} | |
/*! | |
\fn bool QDomNamedNodeMap::isEmpty() const | |
Returns true if the map is empty; otherwise returns false. This function is | |
provided for Qt API consistency. | |
*/ | |
/*! | |
\fn int QDomNamedNodeMap::count() const | |
This function is provided for Qt API consistency. It is equivalent to length(). | |
*/ | |
/*! | |
\fn int QDomNamedNodeMap::size() const | |
This function is provided for Qt API consistency. It is equivalent to length(). | |
*/ | |
/*! | |
Returns true if the map contains a node called \a name; otherwise | |
returns false. | |
\bold{Note:} This function does not take the presence of namespaces into account. | |
Use namedItemNS() to test whether the map contains a node with a specific namespace | |
URI and name. | |
*/ | |
bool QDomNamedNodeMap::contains(const QString& name) const | |
{ | |
if (!impl) | |
return false; | |
return IMPL->contains(name); | |
} | |
#undef IMPL | |
/************************************************************** | |
* | |
* QDomDocumentTypePrivate | |
* | |
**************************************************************/ | |
QDomDocumentTypePrivate::QDomDocumentTypePrivate(QDomDocumentPrivate* doc, QDomNodePrivate* parent) | |
: QDomNodePrivate(doc, parent) | |
{ | |
init(); | |
} | |
QDomDocumentTypePrivate::QDomDocumentTypePrivate(QDomDocumentTypePrivate* n, bool deep) | |
: QDomNodePrivate(n, deep) | |
{ | |
init(); | |
// Refill the maps with our new children | |
QDomNodePrivate* p = first; | |
while (p) { | |
if (p->isEntity()) | |
// Dont use normal insert function since we would create infinite recursion | |
entities->map.insertMulti(p->nodeName(), p); | |
if (p->isNotation()) | |
// Dont use normal insert function since we would create infinite recursion | |
notations->map.insertMulti(p->nodeName(), p); | |
p = p->next; | |
} | |
} | |
QDomDocumentTypePrivate::~QDomDocumentTypePrivate() | |
{ | |
if (!entities->ref.deref()) | |
delete entities; | |
if (!notations->ref.deref()) | |
delete notations; | |
} | |
void QDomDocumentTypePrivate::init() | |
{ | |
entities = new QDomNamedNodeMapPrivate(this); | |
QT_TRY { | |
notations = new QDomNamedNodeMapPrivate(this); | |
publicId.clear(); | |
systemId.clear(); | |
internalSubset.clear(); | |
entities->setAppendToParent(true); | |
notations->setAppendToParent(true); | |
} QT_CATCH(...) { | |
delete entities; | |
QT_RETHROW; | |
} | |
} | |
QDomNodePrivate* QDomDocumentTypePrivate::cloneNode(bool deep) | |
{ | |
QDomNodePrivate* p = new QDomDocumentTypePrivate(this, deep); | |
// We are not interested in this node | |
p->ref.deref(); | |
return p; | |
} | |
QDomNodePrivate* QDomDocumentTypePrivate::insertBefore(QDomNodePrivate* newChild, QDomNodePrivate* refChild) | |
{ | |
// Call the origianl implementation | |
QDomNodePrivate* p = QDomNodePrivate::insertBefore(newChild, refChild); | |
// Update the maps | |
if (p && p->isEntity()) | |
entities->map.insertMulti(p->nodeName(), p); | |
else if (p && p->isNotation()) | |
notations->map.insertMulti(p->nodeName(), p); | |
return p; | |
} | |
QDomNodePrivate* QDomDocumentTypePrivate::insertAfter(QDomNodePrivate* newChild, QDomNodePrivate* refChild) | |
{ | |
// Call the origianl implementation | |
QDomNodePrivate* p = QDomNodePrivate::insertAfter(newChild, refChild); | |
// Update the maps | |
if (p && p->isEntity()) | |
entities->map.insertMulti(p->nodeName(), p); | |
else if (p && p->isNotation()) | |
notations->map.insertMulti(p->nodeName(), p); | |
return p; | |
} | |
QDomNodePrivate* QDomDocumentTypePrivate::replaceChild(QDomNodePrivate* newChild, QDomNodePrivate* oldChild) | |
{ | |
// Call the origianl implementation | |
QDomNodePrivate* p = QDomNodePrivate::replaceChild(newChild, oldChild); | |
// Update the maps | |
if (p) { | |
if (oldChild && oldChild->isEntity()) | |
entities->map.remove(oldChild->nodeName()); | |
else if (oldChild && oldChild->isNotation()) | |
notations->map.remove(oldChild->nodeName()); | |
if (p->isEntity()) | |
entities->map.insertMulti(p->nodeName(), p); | |
else if (p->isNotation()) | |
notations->map.insertMulti(p->nodeName(), p); | |
} | |
return p; | |
} | |
QDomNodePrivate* QDomDocumentTypePrivate::removeChild(QDomNodePrivate* oldChild) | |
{ | |
// Call the origianl implementation | |
QDomNodePrivate* p = QDomNodePrivate::removeChild( oldChild); | |
// Update the maps | |
if (p && p->isEntity()) | |
entities->map.remove(p->nodeName()); | |
else if (p && p->isNotation()) | |
notations->map.remove(p ->nodeName()); | |
return p; | |
} | |
QDomNodePrivate* QDomDocumentTypePrivate::appendChild(QDomNodePrivate* newChild) | |
{ | |
return insertAfter(newChild, 0); | |
} | |
static QString quotedValue(const QString &data) | |
{ | |
QChar quote = data.indexOf(QLatin1Char('\'')) == -1 | |
? QLatin1Char('\'') | |
: QLatin1Char('"'); | |
return quote + data + quote; | |
} | |
void QDomDocumentTypePrivate::save(QTextStream& s, int, int indent) const | |
{ | |
if (name.isEmpty()) | |
return; | |
s << "<!DOCTYPE " << name; | |
if (!publicId.isNull()) { | |
s << " PUBLIC " << quotedValue(publicId); | |
if (!systemId.isNull()) { | |
s << ' ' << quotedValue(systemId); | |
} | |
} else if (!systemId.isNull()) { | |
s << " SYSTEM " << quotedValue(systemId); | |
} | |
if (entities->length()>0 || notations->length()>0) { | |
s << " [" << endl; | |
QHash<QString, QDomNodePrivate *>::const_iterator it2 = notations->map.constBegin(); | |
for (; it2 != notations->map.constEnd(); ++it2) | |
(*it2)->save(s, 0, indent); | |
QHash<QString, QDomNodePrivate *>::const_iterator it = entities->map.constBegin(); | |
for (; it != entities->map.constEnd(); ++it) | |
(*it)->save(s, 0, indent); | |
s << ']'; | |
} | |
s << '>' << endl; | |
} | |
/************************************************************** | |
* | |
* QDomDocumentType | |
* | |
**************************************************************/ | |
#define IMPL ((QDomDocumentTypePrivate*)impl) | |
/*! | |
\class QDomDocumentType | |
\reentrant | |
\brief The QDomDocumentType class is the representation of the DTD | |
in the document tree. | |
\inmodule QtXml | |
\ingroup xml-tools | |
The QDomDocumentType class allows read-only access to some of the | |
data structures in the DTD: it can return a map of all entities() | |
and notations(). In addition the function name() returns the name | |
of the document type as specified in the <!DOCTYPE name> | |
tag. This class also provides the publicId(), systemId() and | |
internalSubset() functions. | |
\sa QDomDocument | |
*/ | |
/*! | |
Creates an empty QDomDocumentType object. | |
*/ | |
QDomDocumentType::QDomDocumentType() : QDomNode() | |
{ | |
} | |
/*! | |
Constructs a copy of \a n. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomDocumentType::QDomDocumentType(const QDomDocumentType& n) | |
: QDomNode(n) | |
{ | |
} | |
QDomDocumentType::QDomDocumentType(QDomDocumentTypePrivate* n) | |
: QDomNode(n) | |
{ | |
} | |
/*! | |
Assigns \a n to this document type. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomDocumentType& QDomDocumentType::operator= (const QDomDocumentType& n) | |
{ | |
return (QDomDocumentType&) QDomNode::operator=(n); | |
} | |
/*! | |
Returns the name of the document type as specified in the | |
<!DOCTYPE name> tag. | |
\sa nodeName() | |
*/ | |
QString QDomDocumentType::name() const | |
{ | |
if (!impl) | |
return QString(); | |
return IMPL->nodeName(); | |
} | |
/*! | |
Returns a map of all entities described in the DTD. | |
*/ | |
QDomNamedNodeMap QDomDocumentType::entities() const | |
{ | |
if (!impl) | |
return QDomNamedNodeMap(); | |
return QDomNamedNodeMap(IMPL->entities); | |
} | |
/*! | |
Returns a map of all notations described in the DTD. | |
*/ | |
QDomNamedNodeMap QDomDocumentType::notations() const | |
{ | |
if (!impl) | |
return QDomNamedNodeMap(); | |
return QDomNamedNodeMap(IMPL->notations); | |
} | |
/*! | |
Returns the public identifier of the external DTD subset or | |
an empty string if there is no public identifier. | |
\sa systemId() internalSubset() QDomImplementation::createDocumentType() | |
*/ | |
QString QDomDocumentType::publicId() const | |
{ | |
if (!impl) | |
return QString(); | |
return IMPL->publicId; | |
} | |
/*! | |
Returns the system identifier of the external DTD subset or | |
an empty string if there is no system identifier. | |
\sa publicId() internalSubset() QDomImplementation::createDocumentType() | |
*/ | |
QString QDomDocumentType::systemId() const | |
{ | |
if (!impl) | |
return QString(); | |
return IMPL->systemId; | |
} | |
/*! | |
Returns the internal subset of the document type or an empty | |
string if there is no internal subset. | |
\sa publicId() systemId() | |
*/ | |
QString QDomDocumentType::internalSubset() const | |
{ | |
if (!impl) | |
return QString(); | |
return IMPL->internalSubset; | |
} | |
/* | |
Are these needed at all? The only difference when removing these | |
two methods in all subclasses is that we'd get a different type | |
for null nodes. | |
*/ | |
/*! | |
\fn QDomNode::NodeType QDomDocumentType::nodeType() const | |
Returns \c DocumentTypeNode. | |
\sa isDocumentType() QDomNode::toDocumentType() | |
*/ | |
#undef IMPL | |
/************************************************************** | |
* | |
* QDomDocumentFragmentPrivate | |
* | |
**************************************************************/ | |
QDomDocumentFragmentPrivate::QDomDocumentFragmentPrivate(QDomDocumentPrivate* doc, QDomNodePrivate* parent) | |
: QDomNodePrivate(doc, parent) | |
{ | |
name = QLatin1String("#document-fragment"); | |
} | |
QDomDocumentFragmentPrivate::QDomDocumentFragmentPrivate(QDomNodePrivate* n, bool deep) | |
: QDomNodePrivate(n, deep) | |
{ | |
} | |
QDomNodePrivate* QDomDocumentFragmentPrivate::cloneNode(bool deep) | |
{ | |
QDomNodePrivate* p = new QDomDocumentFragmentPrivate(this, deep); | |
// We are not interested in this node | |
p->ref.deref(); | |
return p; | |
} | |
/************************************************************** | |
* | |
* QDomDocumentFragment | |
* | |
**************************************************************/ | |
/*! | |
\class QDomDocumentFragment | |
\reentrant | |
\brief The QDomDocumentFragment class is a tree of QDomNodes which is not usually a complete QDomDocument. | |
\inmodule QtXml | |
\ingroup xml-tools | |
If you want to do complex tree operations it is useful to have a | |
lightweight class to store nodes and their relations. | |
QDomDocumentFragment stores a subtree of a document which does not | |
necessarily represent a well-formed XML document. | |
QDomDocumentFragment is also useful if you want to group several | |
nodes in a list and insert them all together as children of some | |
node. In these cases QDomDocumentFragment can be used as a | |
temporary container for this list of children. | |
The most important feature of QDomDocumentFragment is that it is | |
treated in a special way by QDomNode::insertAfter(), | |
QDomNode::insertBefore(), QDomNode::replaceChild() and | |
QDomNode::appendChild(): instead of inserting the fragment itself, all | |
the fragment's children are inserted. | |
*/ | |
/*! | |
Constructs an empty document fragment. | |
*/ | |
QDomDocumentFragment::QDomDocumentFragment() | |
{ | |
} | |
QDomDocumentFragment::QDomDocumentFragment(QDomDocumentFragmentPrivate* n) | |
: QDomNode(n) | |
{ | |
} | |
/*! | |
Constructs a copy of \a x. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomDocumentFragment::QDomDocumentFragment(const QDomDocumentFragment& x) | |
: QDomNode(x) | |
{ | |
} | |
/*! | |
Assigns \a x to this DOM document fragment. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomDocumentFragment& QDomDocumentFragment::operator= (const QDomDocumentFragment& x) | |
{ | |
return (QDomDocumentFragment&) QDomNode::operator=(x); | |
} | |
/*! | |
\fn QDomNode::NodeType QDomDocumentFragment::nodeType() const | |
Returns \c DocumentFragment. | |
\sa isDocumentFragment() QDomNode::toDocumentFragment() | |
*/ | |
/************************************************************** | |
* | |
* QDomCharacterDataPrivate | |
* | |
**************************************************************/ | |
QDomCharacterDataPrivate::QDomCharacterDataPrivate(QDomDocumentPrivate* d, QDomNodePrivate* p, | |
const QString& data) | |
: QDomNodePrivate(d, p) | |
{ | |
value = data; | |
name = QLatin1String("#character-data"); | |
} | |
QDomCharacterDataPrivate::QDomCharacterDataPrivate(QDomCharacterDataPrivate* n, bool deep) | |
: QDomNodePrivate(n, deep) | |
{ | |
} | |
QDomNodePrivate* QDomCharacterDataPrivate::cloneNode(bool deep) | |
{ | |
QDomNodePrivate* p = new QDomCharacterDataPrivate(this, deep); | |
// We are not interested in this node | |
p->ref.deref(); | |
return p; | |
} | |
uint QDomCharacterDataPrivate::dataLength() const | |
{ | |
return value.length(); | |
} | |
QString QDomCharacterDataPrivate::substringData(unsigned long offset, unsigned long n) const | |
{ | |
return value.mid(offset, n); | |
} | |
void QDomCharacterDataPrivate::insertData(unsigned long offset, const QString& arg) | |
{ | |
value.insert(offset, arg); | |
} | |
void QDomCharacterDataPrivate::deleteData(unsigned long offset, unsigned long n) | |
{ | |
value.remove(offset, n); | |
} | |
void QDomCharacterDataPrivate::replaceData(unsigned long offset, unsigned long n, const QString& arg) | |
{ | |
value.replace(offset, n, arg); | |
} | |
void QDomCharacterDataPrivate::appendData(const QString& arg) | |
{ | |
value += arg; | |
} | |
/************************************************************** | |
* | |
* QDomCharacterData | |
* | |
**************************************************************/ | |
#define IMPL ((QDomCharacterDataPrivate*)impl) | |
/*! | |
\class QDomCharacterData | |
\reentrant | |
\brief The QDomCharacterData class represents a generic string in the DOM. | |
\inmodule QtXml | |
\ingroup xml-tools | |
Character data as used in XML specifies a generic data string. | |
More specialized versions of this class are QDomText, QDomComment | |
and QDomCDATASection. | |
The data string is set with setData() and retrieved with data(). | |
You can retrieve a portion of the data string using | |
substringData(). Extra data can be appended with appendData(), or | |
inserted with insertData(). Portions of the data string can be | |
deleted with deleteData() or replaced with replaceData(). The | |
length of the data string is returned by length(). | |
The node type of the node containing this character data is | |
returned by nodeType(). | |
\sa QDomText QDomComment QDomCDATASection | |
*/ | |
/*! | |
Constructs an empty character data object. | |
*/ | |
QDomCharacterData::QDomCharacterData() | |
{ | |
} | |
/*! | |
Constructs a copy of \a x. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomCharacterData::QDomCharacterData(const QDomCharacterData& x) | |
: QDomNode(x) | |
{ | |
} | |
QDomCharacterData::QDomCharacterData(QDomCharacterDataPrivate* n) | |
: QDomNode(n) | |
{ | |
} | |
/*! | |
Assigns \a x to this character data. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomCharacterData& QDomCharacterData::operator= (const QDomCharacterData& x) | |
{ | |
return (QDomCharacterData&) QDomNode::operator=(x); | |
} | |
/*! | |
Returns the string stored in this object. | |
If the node is a \link isNull() null node\endlink, it will return | |
an empty string. | |
*/ | |
QString QDomCharacterData::data() const | |
{ | |
if (!impl) | |
return QString(); | |
return impl->nodeValue(); | |
} | |
/*! | |
Sets this object's string to \a v. | |
*/ | |
void QDomCharacterData::setData(const QString& v) | |
{ | |
if (impl) | |
impl->setNodeValue(v); | |
} | |
/*! | |
Returns the length of the stored string. | |
*/ | |
uint QDomCharacterData::length() const | |
{ | |
if (impl) | |
return IMPL->dataLength(); | |
return 0; | |
} | |
/*! | |
Returns the substring of length \a count from position \a offset. | |
*/ | |
QString QDomCharacterData::substringData(unsigned long offset, unsigned long count) | |
{ | |
if (!impl) | |
return QString(); | |
return IMPL->substringData(offset, count); | |
} | |
/*! | |
Appends the string \a arg to the stored string. | |
*/ | |
void QDomCharacterData::appendData(const QString& arg) | |
{ | |
if (impl) | |
IMPL->appendData(arg); | |
} | |
/*! | |
Inserts the string \a arg into the stored string at position \a offset. | |
*/ | |
void QDomCharacterData::insertData(unsigned long offset, const QString& arg) | |
{ | |
if (impl) | |
IMPL->insertData(offset, arg); | |
} | |
/*! | |
Deletes a substring of length \a count from position \a offset. | |
*/ | |
void QDomCharacterData::deleteData(unsigned long offset, unsigned long count) | |
{ | |
if (impl) | |
IMPL->deleteData(offset, count); | |
} | |
/*! | |
Replaces the substring of length \a count starting at position \a | |
offset with the string \a arg. | |
*/ | |
void QDomCharacterData::replaceData(unsigned long offset, unsigned long count, const QString& arg) | |
{ | |
if (impl) | |
IMPL->replaceData(offset, count, arg); | |
} | |
/*! | |
Returns the type of node this object refers to (i.e. \c TextNode, | |
\c CDATASectionNode, \c CommentNode or \c CharacterDataNode). For | |
a \link isNull() null node\endlink, returns \c CharacterDataNode. | |
*/ | |
QDomNode::NodeType QDomCharacterData::nodeType() const | |
{ | |
if (!impl) | |
return CharacterDataNode; | |
return QDomNode::nodeType(); | |
} | |
#undef IMPL | |
/************************************************************** | |
* | |
* QDomAttrPrivate | |
* | |
**************************************************************/ | |
QDomAttrPrivate::QDomAttrPrivate(QDomDocumentPrivate* d, QDomNodePrivate* parent, const QString& name_) | |
: QDomNodePrivate(d, parent) | |
{ | |
name = name_; | |
m_specified = false; | |
} | |
QDomAttrPrivate::QDomAttrPrivate(QDomDocumentPrivate* d, QDomNodePrivate* p, const QString& nsURI, const QString& qName) | |
: QDomNodePrivate(d, p) | |
{ | |
qt_split_namespace(prefix, name, qName, !nsURI.isNull()); | |
namespaceURI = nsURI; | |
createdWithDom1Interface = false; | |
m_specified = false; | |
} | |
QDomAttrPrivate::QDomAttrPrivate(QDomAttrPrivate* n, bool deep) | |
: QDomNodePrivate(n, deep) | |
{ | |
m_specified = n->specified(); | |
} | |
void QDomAttrPrivate::setNodeValue(const QString& v) | |
{ | |
value = v; | |
QDomTextPrivate *t = new QDomTextPrivate(0, this, v); | |
// keep the refcount balanced: appendChild() does a ref anyway. | |
t->ref.deref(); | |
if (first) { | |
delete removeChild(first); | |
} | |
appendChild(t); | |
} | |
QDomNodePrivate* QDomAttrPrivate::cloneNode(bool deep) | |
{ | |
QDomNodePrivate* p = new QDomAttrPrivate(this, deep); | |
// We are not interested in this node | |
p->ref.deref(); | |
return p; | |
} | |
bool QDomAttrPrivate::specified() const | |
{ | |
return m_specified; | |
} | |
/* \internal | |
Encode & escape \a str. Yes, it makes no sense to return a QString, | |
but is so for legacy reasons. | |
Remember that content produced should be able to roundtrip with 2.11 End-of-Line Handling | |
and 3.3.3 Attribute-Value Normalization. | |
If \a performAVN is true, characters will be escaped to survive Attribute Value Normalization. | |
If \a encodeEOLs is true, characters will be escaped to survive End-of-Line Handling. | |
*/ | |
static QString encodeText(const QString &str, | |
QTextStream &s, | |
const bool encodeQuotes = true, | |
const bool performAVN = false, | |
const bool encodeEOLs = false) | |
{ | |
#ifdef QT_NO_TEXTCODEC | |
Q_UNUSED(s); | |
#else | |
const QTextCodec *const codec = s.codec(); | |
Q_ASSERT(codec); | |
#endif | |
QString retval(str); | |
int len = retval.length(); | |
int i = 0; | |
while (i < len) { | |
const QChar ati(retval.at(i)); | |
if (ati == QLatin1Char('<')) { | |
retval.replace(i, 1, QLatin1String("<")); | |
len += 3; | |
i += 4; | |
} else if (encodeQuotes && (ati == QLatin1Char('"'))) { | |
retval.replace(i, 1, QLatin1String(""")); | |
len += 5; | |
i += 6; | |
} else if (ati == QLatin1Char('&')) { | |
retval.replace(i, 1, QLatin1String("&")); | |
len += 4; | |
i += 5; | |
} else if (ati == QLatin1Char('>') && i >= 2 && retval[i - 1] == QLatin1Char(']') && retval[i - 2] == QLatin1Char(']')) { | |
retval.replace(i, 1, QLatin1String(">")); | |
len += 3; | |
i += 4; | |
} else if (performAVN && | |
(ati == QChar(0xA) || | |
ati == QChar(0xD) || | |
ati == QChar(0x9))) { | |
const QString replacement(QLatin1String("&#x") + QString::number(ati.unicode(), 16) + QLatin1Char(';')); | |
retval.replace(i, 1, replacement); | |
i += replacement.length(); | |
len += replacement.length() - 1; | |
} else if (encodeEOLs && ati == QChar(0xD)) { | |
retval.replace(i, 1, QLatin1String("
")); // Replace a single 0xD with a ref for 0xD | |
len += 4; | |
i += 5; | |
} else { | |
#ifndef QT_NO_TEXTCODEC | |
if(codec->canEncode(ati)) | |
++i; | |
else | |
#endif | |
{ | |
// We have to use a character reference to get it through. | |
const ushort codepoint(ati.unicode()); | |
const QString replacement(QLatin1String("&#x") + QString::number(codepoint, 16) + QLatin1Char(';')); | |
retval.replace(i, 1, replacement); | |
i += replacement.length(); | |
len += replacement.length() - 1; | |
} | |
} | |
} | |
return retval; | |
} | |
void QDomAttrPrivate::save(QTextStream& s, int, int) const | |
{ | |
if (namespaceURI.isNull()) { | |
s << name << "=\"" << encodeText(value, s, true, true) << '\"'; | |
} else { | |
s << prefix << ':' << name << "=\"" << encodeText(value, s, true, true) << '\"'; | |
/* This is a fix for 138243, as good as it gets. | |
* | |
* QDomElementPrivate::save() output a namespace declaration if | |
* the element is in a namespace, no matter what. This function do as well, meaning | |
* that we get two identical namespace declaration if we don't have the if- | |
* statement below. | |
* | |
* This doesn't work when the parent element has the same prefix as us but | |
* a different namespace. However, this can only occur by the user modifying the element, | |
* and we don't do fixups by that anyway, and hence it's the user responsibility to not | |
* arrive in those situations. */ | |
if(!ownerNode || | |
ownerNode->prefix != prefix) { | |
s << " xmlns:" << prefix << "=\"" << encodeText(namespaceURI, s, true, true) << '\"'; | |
} | |
} | |
} | |
/************************************************************** | |
* | |
* QDomAttr | |
* | |
**************************************************************/ | |
#define IMPL ((QDomAttrPrivate*)impl) | |
/*! | |
\class QDomAttr | |
\reentrant | |
\brief The QDomAttr class represents one attribute of a QDomElement. | |
\inmodule QtXml | |
\ingroup xml-tools | |
For example, the following piece of XML produces an element with | |
no children, but two attributes: | |
\snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 7 | |
You can access the attributes of an element with code like this: | |
\snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 8 | |
This example also shows that changing an attribute received from | |
an element changes the attribute of the element. If you do not | |
want to change the value of the element's attribute you must | |
use cloneNode() to get an independent copy of the attribute. | |
QDomAttr can return the name() and value() of an attribute. An | |
attribute's value is set with setValue(). If specified() returns | |
true the value was set with setValue(). The node this | |
attribute is attached to (if any) is returned by ownerElement(). | |
For further information about the Document Object Model see | |
\l{http://www.w3.org/TR/REC-DOM-Level-1/} and | |
\l{http://www.w3.org/TR/DOM-Level-2-Core/}. | |
For a more general introduction of the DOM implementation see the | |
QDomDocument documentation. | |
*/ | |
/*! | |
Constructs an empty attribute. | |
*/ | |
QDomAttr::QDomAttr() | |
{ | |
} | |
/*! | |
Constructs a copy of \a x. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomAttr::QDomAttr(const QDomAttr& x) | |
: QDomNode(x) | |
{ | |
} | |
QDomAttr::QDomAttr(QDomAttrPrivate* n) | |
: QDomNode(n) | |
{ | |
} | |
/*! | |
Assigns \a x to this DOM attribute. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomAttr& QDomAttr::operator= (const QDomAttr& x) | |
{ | |
return (QDomAttr&) QDomNode::operator=(x); | |
} | |
/*! | |
Returns the attribute's name. | |
*/ | |
QString QDomAttr::name() const | |
{ | |
if (!impl) | |
return QString(); | |
return impl->nodeName(); | |
} | |
/*! | |
Returns true if the attribute has been set by the user with setValue(). | |
Returns false if the value hasn't been specified or set. | |
\sa setValue() | |
*/ | |
bool QDomAttr::specified() const | |
{ | |
if (!impl) | |
return false; | |
return IMPL->specified(); | |
} | |
/*! | |
Returns the element node this attribute is attached to or a \link | |
QDomNode::isNull() null node\endlink if this attribute is not | |
attached to any element. | |
*/ | |
QDomElement QDomAttr::ownerElement() const | |
{ | |
Q_ASSERT(impl->parent()); | |
if (!impl->parent()->isElement()) | |
return QDomElement(); | |
return QDomElement((QDomElementPrivate*)(impl->parent())); | |
} | |
/*! | |
Returns the value of the attribute or an empty string if the | |
attribute has not been specified. | |
\sa specified() setValue() | |
*/ | |
QString QDomAttr::value() const | |
{ | |
if (!impl) | |
return QString(); | |
return impl->nodeValue(); | |
} | |
/*! | |
Sets the attribute's value to \a v. | |
\sa value() | |
*/ | |
void QDomAttr::setValue(const QString& v) | |
{ | |
if (!impl) | |
return; | |
impl->setNodeValue(v); | |
IMPL->m_specified = true; | |
} | |
/*! | |
\fn QDomNode::NodeType QDomAttr::nodeType() const | |
Returns \link QDomNode::NodeType AttributeNode\endlink. | |
*/ | |
#undef IMPL | |
/************************************************************** | |
* | |
* QDomElementPrivate | |
* | |
**************************************************************/ | |
QDomElementPrivate::QDomElementPrivate(QDomDocumentPrivate* d, QDomNodePrivate* p, | |
const QString& tagname) | |
: QDomNodePrivate(d, p) | |
{ | |
name = tagname; | |
m_attr = new QDomNamedNodeMapPrivate(this); | |
} | |
QDomElementPrivate::QDomElementPrivate(QDomDocumentPrivate* d, QDomNodePrivate* p, | |
const QString& nsURI, const QString& qName) | |
: QDomNodePrivate(d, p) | |
{ | |
qt_split_namespace(prefix, name, qName, !nsURI.isNull()); | |
namespaceURI = nsURI; | |
createdWithDom1Interface = false; | |
m_attr = new QDomNamedNodeMapPrivate(this); | |
} | |
QDomElementPrivate::QDomElementPrivate(QDomElementPrivate* n, bool deep) : | |
QDomNodePrivate(n, deep) | |
{ | |
m_attr = n->m_attr->clone(this); | |
// Reference is down to 0, so we set it to 1 here. | |
m_attr->ref.ref(); | |
} | |
QDomElementPrivate::~QDomElementPrivate() | |
{ | |
if (!m_attr->ref.deref()) | |
delete m_attr; | |
} | |
QDomNodePrivate* QDomElementPrivate::cloneNode(bool deep) | |
{ | |
QDomNodePrivate* p = new QDomElementPrivate(this, deep); | |
// We are not interested in this node | |
p->ref.deref(); | |
return p; | |
} | |
QString QDomElementPrivate::attribute(const QString& name_, const QString& defValue) const | |
{ | |
QDomNodePrivate* n = m_attr->namedItem(name_); | |
if (!n) | |
return defValue; | |
return n->nodeValue(); | |
} | |
QString QDomElementPrivate::attributeNS(const QString& nsURI, const QString& localName, const QString& defValue) const | |
{ | |
QDomNodePrivate* n = m_attr->namedItemNS(nsURI, localName); | |
if (!n) | |
return defValue; | |
return n->nodeValue(); | |
} | |
void QDomElementPrivate::setAttribute(const QString& aname, const QString& newValue) | |
{ | |
QDomNodePrivate* n = m_attr->namedItem(aname); | |
if (!n) { | |
n = new QDomAttrPrivate(ownerDocument(), this, aname); | |
n->setNodeValue(newValue); | |
// Referencing is done by the map, so we set the reference counter back | |
// to 0 here. This is ok since we created the QDomAttrPrivate. | |
n->ref.deref(); | |
m_attr->setNamedItem(n); | |
} else { | |
n->setNodeValue(newValue); | |
} | |
} | |
void QDomElementPrivate::setAttributeNS(const QString& nsURI, const QString& qName, const QString& newValue) | |
{ | |
QString prefix, localName; | |
qt_split_namespace(prefix, localName, qName, true); | |
QDomNodePrivate* n = m_attr->namedItemNS(nsURI, localName); | |
if (!n) { | |
n = new QDomAttrPrivate(ownerDocument(), this, nsURI, qName); | |
n->setNodeValue(newValue); | |
// Referencing is done by the map, so we set the reference counter back | |
// to 0 here. This is ok since we created the QDomAttrPrivate. | |
n->ref.deref(); | |
m_attr->setNamedItem(n); | |
} else { | |
n->setNodeValue(newValue); | |
n->prefix = prefix; | |
} | |
} | |
void QDomElementPrivate::removeAttribute(const QString& aname) | |
{ | |
QDomNodePrivate* p = m_attr->removeNamedItem(aname); | |
if (p && p->ref == 0) | |
delete p; | |
} | |
QDomAttrPrivate* QDomElementPrivate::attributeNode(const QString& aname) | |
{ | |
return (QDomAttrPrivate*)m_attr->namedItem(aname); | |
} | |
QDomAttrPrivate* QDomElementPrivate::attributeNodeNS(const QString& nsURI, const QString& localName) | |
{ | |
return (QDomAttrPrivate*)m_attr->namedItemNS(nsURI, localName); | |
} | |
QDomAttrPrivate* QDomElementPrivate::setAttributeNode(QDomAttrPrivate* newAttr) | |
{ | |
QDomNodePrivate* n = m_attr->namedItem(newAttr->nodeName()); | |
// Referencing is done by the maps | |
m_attr->setNamedItem(newAttr); | |
newAttr->setParent(this); | |
return (QDomAttrPrivate*)n; | |
} | |
QDomAttrPrivate* QDomElementPrivate::setAttributeNodeNS(QDomAttrPrivate* newAttr) | |
{ | |
QDomNodePrivate* n = 0; | |
if (!newAttr->prefix.isNull()) | |
n = m_attr->namedItemNS(newAttr->namespaceURI, newAttr->name); | |
// Referencing is done by the maps | |
m_attr->setNamedItem(newAttr); | |
return (QDomAttrPrivate*)n; | |
} | |
QDomAttrPrivate* QDomElementPrivate::removeAttributeNode(QDomAttrPrivate* oldAttr) | |
{ | |
return (QDomAttrPrivate*)m_attr->removeNamedItem(oldAttr->nodeName()); | |
} | |
bool QDomElementPrivate::hasAttribute(const QString& aname) | |
{ | |
return m_attr->contains(aname); | |
} | |
bool QDomElementPrivate::hasAttributeNS(const QString& nsURI, const QString& localName) | |
{ | |
return m_attr->containsNS(nsURI, localName); | |
} | |
QString QDomElementPrivate::text() | |
{ | |
QString t(QLatin1String("")); | |
QDomNodePrivate* p = first; | |
while (p) { | |
if (p->isText() || p->isCDATASection()) | |
t += p->nodeValue(); | |
else if (p->isElement()) | |
t += ((QDomElementPrivate*)p)->text(); | |
p = p->next; | |
} | |
return t; | |
} | |
void QDomElementPrivate::save(QTextStream& s, int depth, int indent) const | |
{ | |
if (!(prev && prev->isText())) | |
s << QString(indent < 1 ? 0 : depth * indent, QLatin1Char(' ')); | |
QString qName(name); | |
QString nsDecl(QLatin1String("")); | |
if (!namespaceURI.isNull()) { | |
/** ### Qt 5: | |
* | |
* If we still have QDom, optimize this so that we only declare namespaces that are not | |
* yet declared. We loose default namespace mappings, so maybe we should rather store | |
* the information that we get from startPrefixMapping()/endPrefixMapping() and use them. | |
* Modifications becomes more complex then, however. | |
* | |
* We cannot do this during the Qt 4 series because it would require too invasive changes, and | |
* hence possibly behavioral changes. | |
*/ | |
if (prefix.isEmpty()) { | |
nsDecl = QLatin1String(" xmlns"); | |
} else { | |
qName = prefix + QLatin1Char(':') + name; | |
nsDecl = QLatin1String(" xmlns:") + prefix; | |
} | |
nsDecl += QLatin1String("=\"") + encodeText(namespaceURI, s) + QLatin1Char('\"'); | |
} | |
s << '<' << qName << nsDecl; | |
QSet<QString> outputtedPrefixes; | |
/* Write out attributes. */ | |
if (!m_attr->map.isEmpty()) { | |
QHash<QString, QDomNodePrivate *>::const_iterator it = m_attr->map.constBegin(); | |
for (; it != m_attr->map.constEnd(); ++it) { | |
s << ' '; | |
if (it.value()->namespaceURI.isNull()) { | |
s << it.value()->name << "=\"" << encodeText(it.value()->value, s, true, true) << '\"'; | |
} else { | |
s << it.value()->prefix << ':' << it.value()->name << "=\"" << encodeText(it.value()->value, s, true, true) << '\"'; | |
/* This is a fix for 138243, as good as it gets. | |
* | |
* QDomElementPrivate::save() output a namespace declaration if | |
* the element is in a namespace, no matter what. This function do as well, meaning | |
* that we get two identical namespace declaration if we don't have the if- | |
* statement below. | |
* | |
* This doesn't work when the parent element has the same prefix as us but | |
* a different namespace. However, this can only occur by the user modifying the element, | |
* and we don't do fixups by that anyway, and hence it's the user responsibility to not | |
* arrive in those situations. */ | |
if((!it.value()->ownerNode || | |
it.value()->ownerNode->prefix != it.value()->prefix) && | |
!outputtedPrefixes.contains(it.value()->prefix)) { | |
s << " xmlns:" << it.value()->prefix << "=\"" << encodeText(it.value()->namespaceURI, s, true, true) << '\"'; | |
outputtedPrefixes.insert(it.value()->prefix); | |
} | |
} | |
} | |
} | |
if (last) { | |
// has child nodes | |
if (first->isText()) | |
s << '>'; | |
else { | |
s << '>'; | |
/* -1 disables new lines. */ | |
if (indent != -1) | |
s << endl; | |
} | |
QDomNodePrivate::save(s, depth + 1, indent); if (!last->isText()) | |
s << QString(indent < 1 ? 0 : depth * indent, QLatin1Char(' ')); | |
s << "</" << qName << '>'; | |
} else { | |
s << "/>"; | |
} | |
if (!(next && next->isText())) { | |
/* -1 disables new lines. */ | |
if (indent != -1) | |
s << endl; | |
} | |
} | |
/************************************************************** | |
* | |
* QDomElement | |
* | |
**************************************************************/ | |
#define IMPL ((QDomElementPrivate*)impl) | |
/*! | |
\class QDomElement | |
\reentrant | |
\brief The QDomElement class represents one element in the DOM tree. | |
\inmodule QtXml | |
\ingroup xml-tools | |
Elements have a tagName() and zero or more attributes associated | |
with them. The tag name can be changed with setTagName(). | |
Element attributes are represented by QDomAttr objects that can | |
be queried using the attribute() and attributeNode() functions. | |
You can set attributes with the setAttribute() and | |
setAttributeNode() functions. Attributes can be removed with | |
removeAttribute(). There are namespace-aware equivalents to these | |
functions, i.e. setAttributeNS(), setAttributeNodeNS() and | |
removeAttributeNS(). | |
If you want to access the text of a node use text(), e.g. | |
\snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 9 | |
The text() function operates recursively to find the text (since | |
not all elements contain text). If you want to find all the text | |
in all of a node's children, iterate over the children looking for | |
QDomText nodes, e.g. | |
\snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 10 | |
Note that we attempt to convert each node to a text node and use | |
text() rather than using firstChild().toText().data() or | |
n.toText().data() directly on the node, because the node may not | |
be a text element. | |
You can get a list of all the decendents of an element which have | |
a specified tag name with elementsByTagName() or | |
elementsByTagNameNS(). | |
To browse the elements of a dom document use firstChildElement(), lastChildElement(), | |
nextSiblingElement() and previousSiblingElement(). For example, to iterate over all | |
child elements called "entry" in a root element called "database", you can use: | |
\snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 11 | |
For further information about the Document Object Model see | |
\l{http://www.w3.org/TR/REC-DOM-Level-1/}{Level 1} and | |
\l{http://www.w3.org/TR/DOM-Level-2-Core/}{Level 2 Core}. | |
For a more general introduction of the DOM implementation see the | |
QDomDocument documentation. | |
*/ | |
/*! | |
Constructs an empty element. Use the QDomDocument::createElement() | |
function to construct elements with content. | |
*/ | |
QDomElement::QDomElement() | |
: QDomNode() | |
{ | |
} | |
/*! | |
Constructs a copy of \a x. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomElement::QDomElement(const QDomElement& x) | |
: QDomNode(x) | |
{ | |
} | |
QDomElement::QDomElement(QDomElementPrivate* n) | |
: QDomNode(n) | |
{ | |
} | |
/*! | |
Assigns \a x to this DOM element. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomElement& QDomElement::operator= (const QDomElement& x) | |
{ | |
return (QDomElement&) QDomNode::operator=(x); | |
} | |
/*! | |
\fn QDomNode::NodeType QDomElement::nodeType() const | |
Returns \c ElementNode. | |
*/ | |
/*! | |
Sets this element's tag name to \a name. | |
\sa tagName() | |
*/ | |
void QDomElement::setTagName(const QString& name) | |
{ | |
if (impl) | |
impl->name = name; | |
} | |
/*! | |
Returns the tag name of this element. For an XML element like this: | |
\snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 12 | |
the tagname would return "img". | |
\sa setTagName() | |
*/ | |
QString QDomElement::tagName() const | |
{ | |
if (!impl) | |
return QString(); | |
return impl->nodeName(); | |
} | |
/*! | |
Returns a QDomNamedNodeMap containing all this element's attributes. | |
\sa attribute() setAttribute() attributeNode() setAttributeNode() | |
*/ | |
QDomNamedNodeMap QDomElement::attributes() const | |
{ | |
if (!impl) | |
return QDomNamedNodeMap(); | |
return QDomNamedNodeMap(IMPL->attributes()); | |
} | |
/*! | |
Returns the attribute called \a name. If the attribute does not | |
exist \a defValue is returned. | |
\sa setAttribute() attributeNode() setAttributeNode() attributeNS() | |
*/ | |
QString QDomElement::attribute(const QString& name, const QString& defValue) const | |
{ | |
if (!impl) | |
return defValue; | |
return IMPL->attribute(name, defValue); | |
} | |
/*! | |
Adds an attribute called \a name with value \a value. If an | |
attribute with the same name exists, its value is replaced by \a | |
value. | |
\sa attribute() setAttributeNode() setAttributeNS() | |
*/ | |
void QDomElement::setAttribute(const QString& name, const QString& value) | |
{ | |
if (!impl) | |
return; | |
IMPL->setAttribute(name, value); | |
} | |
/*! | |
\fn void QDomElement::setAttribute(const QString& name, int value) | |
\overload | |
The number is formatted according to the current locale. | |
*/ | |
/*! | |
\fn void QDomElement::setAttribute(const QString& name, uint value) | |
\overload | |
The number is formatted according to the current locale. | |
*/ | |
/*! | |
\overload | |
The number is formatted according to the current locale. | |
*/ | |
void QDomElement::setAttribute(const QString& name, qlonglong value) | |
{ | |
if (!impl) | |
return; | |
QString x; | |
x.setNum(value); | |
IMPL->setAttribute(name, x); | |
} | |
/*! | |
\overload | |
The number is formatted according to the current locale. | |
*/ | |
void QDomElement::setAttribute(const QString& name, qulonglong value) | |
{ | |
if (!impl) | |
return; | |
QString x; | |
x.setNum(value); | |
IMPL->setAttribute(name, x); | |
} | |
/*! | |
\overload | |
The number is formatted according to the current locale. | |
*/ | |
void QDomElement::setAttribute(const QString& name, float value) | |
{ | |
if (!impl) | |
return; | |
QString x; | |
x.setNum(value); | |
IMPL->setAttribute(name, x); | |
} | |
/*! | |
\overload | |
The number is formatted according to the current locale. | |
*/ | |
void QDomElement::setAttribute(const QString& name, double value) | |
{ | |
if (!impl) | |
return; | |
QString x; | |
char buf[256]; | |
int count = qsnprintf(buf, sizeof(buf), "%.16g", value); | |
if (count > 0) | |
x = QString::fromLatin1(buf, count); | |
else | |
x.setNum(value); // Fallback | |
IMPL->setAttribute(name, x); | |
} | |
/*! | |
Removes the attribute called name \a name from this element. | |
\sa setAttribute() attribute() removeAttributeNS() | |
*/ | |
void QDomElement::removeAttribute(const QString& name) | |
{ | |
if (!impl) | |
return; | |
IMPL->removeAttribute(name); | |
} | |
/*! | |
Returns the QDomAttr object that corresponds to the attribute | |
called \a name. If no such attribute exists a \link | |
QDomNode::isNull() null attribute\endlink is returned. | |
\sa setAttributeNode() attribute() setAttribute() attributeNodeNS() | |
*/ | |
QDomAttr QDomElement::attributeNode(const QString& name) | |
{ | |
if (!impl) | |
return QDomAttr(); | |
return QDomAttr(IMPL->attributeNode(name)); | |
} | |
/*! | |
Adds the attribute \a newAttr to this element. | |
If the element has another attribute that has the same name as \a | |
newAttr, this function replaces that attribute and returns it; | |
otherwise the function returns a \link QDomNode::isNull() null | |
attribute\endlink. | |
\sa attributeNode() setAttribute() setAttributeNodeNS() | |
*/ | |
QDomAttr QDomElement::setAttributeNode(const QDomAttr& newAttr) | |
{ | |
if (!impl) | |
return QDomAttr(); | |
return QDomAttr(IMPL->setAttributeNode(((QDomAttrPrivate*)newAttr.impl))); | |
} | |
/*! | |
Removes the attribute \a oldAttr from the element and returns it. | |
\sa attributeNode() setAttributeNode() | |
*/ | |
QDomAttr QDomElement::removeAttributeNode(const QDomAttr& oldAttr) | |
{ | |
if (!impl) | |
return QDomAttr(); // ### should this return oldAttr? | |
return QDomAttr(IMPL->removeAttributeNode(((QDomAttrPrivate*)oldAttr.impl))); | |
} | |
/*! | |
Returns a QDomNodeList containing all descendants of this element | |
named \a tagname encountered during a preorder traversal of the | |
element subtree with this element as its root. The order of the | |
elements in the returned list is the order they are encountered | |
during the preorder traversal. | |
\sa elementsByTagNameNS() QDomDocument::elementsByTagName() | |
*/ | |
QDomNodeList QDomElement::elementsByTagName(const QString& tagname) const | |
{ | |
return QDomNodeList(new QDomNodeListPrivate(impl, tagname)); | |
} | |
/*! | |
Returns true if this element has an attribute called \a name; | |
otherwise returns false. | |
\bold{Note:} This function does not take the presence of namespaces | |
into account. As a result, the specified name will be tested | |
against fully-qualified attribute names that include any namespace | |
prefixes that may be present. | |
Use hasAttributeNS() to explicitly test for attributes with specific | |
namespaces and names. | |
*/ | |
bool QDomElement::hasAttribute(const QString& name) const | |
{ | |
if (!impl) | |
return false; | |
return IMPL->hasAttribute(name); | |
} | |
/*! | |
Returns the attribute with the local name \a localName and the | |
namespace URI \a nsURI. If the attribute does not exist \a | |
defValue is returned. | |
\sa setAttributeNS() attributeNodeNS() setAttributeNodeNS() attribute() | |
*/ | |
QString QDomElement::attributeNS(const QString nsURI, const QString& localName, const QString& defValue) const | |
{ | |
if (!impl) | |
return defValue; | |
return IMPL->attributeNS(nsURI, localName, defValue); | |
} | |
/*! | |
Adds an attribute with the qualified name \a qName and the | |
namespace URI \a nsURI with the value \a value. If an attribute | |
with the same local name and namespace URI exists, its prefix is | |
replaced by the prefix of \a qName and its value is repaced by \a | |
value. | |
Although \a qName is the qualified name, the local name is used to | |
decide if an existing attribute's value should be replaced. | |
\sa attributeNS() setAttributeNodeNS() setAttribute() | |
*/ | |
void QDomElement::setAttributeNS(const QString nsURI, const QString& qName, const QString& value) | |
{ | |
if (!impl) | |
return; | |
IMPL->setAttributeNS(nsURI, qName, value); | |
} | |
/*! | |
\fn void QDomElement::setAttributeNS(const QString nsURI, const QString& qName, int value) | |
\overload | |
*/ | |
/*! | |
\fn void QDomElement::setAttributeNS(const QString nsURI, const QString& qName, uint value) | |
\overload | |
*/ | |
/*! | |
\overload | |
*/ | |
void QDomElement::setAttributeNS(const QString nsURI, const QString& qName, qlonglong value) | |
{ | |
if (!impl) | |
return; | |
QString x; | |
x.setNum(value); | |
IMPL->setAttributeNS(nsURI, qName, x); | |
} | |
/*! | |
\overload | |
*/ | |
void QDomElement::setAttributeNS(const QString nsURI, const QString& qName, qulonglong value) | |
{ | |
if (!impl) | |
return; | |
QString x; | |
x.setNum(value); | |
IMPL->setAttributeNS(nsURI, qName, x); | |
} | |
/*! | |
\overload | |
*/ | |
void QDomElement::setAttributeNS(const QString nsURI, const QString& qName, double value) | |
{ | |
if (!impl) | |
return; | |
QString x; | |
x.setNum(value); | |
IMPL->setAttributeNS(nsURI, qName, x); | |
} | |
/*! | |
Removes the attribute with the local name \a localName and the | |
namespace URI \a nsURI from this element. | |
\sa setAttributeNS() attributeNS() removeAttribute() | |
*/ | |
void QDomElement::removeAttributeNS(const QString& nsURI, const QString& localName) | |
{ | |
if (!impl) | |
return; | |
QDomNodePrivate *n = IMPL->attributeNodeNS(nsURI, localName); | |
if (!n) | |
return; | |
IMPL->removeAttribute(n->nodeName()); | |
} | |
/*! | |
Returns the QDomAttr object that corresponds to the attribute | |
with the local name \a localName and the namespace URI \a nsURI. | |
If no such attribute exists a \l{QDomNode::isNull()}{null | |
attribute} is returned. | |
\sa setAttributeNode() attribute() setAttribute() | |
*/ | |
QDomAttr QDomElement::attributeNodeNS(const QString& nsURI, const QString& localName) | |
{ | |
if (!impl) | |
return QDomAttr(); | |
return QDomAttr(IMPL->attributeNodeNS(nsURI, localName)); | |
} | |
/*! | |
Adds the attribute \a newAttr to this element. | |
If the element has another attribute that has the same local name | |
and namespace URI as \a newAttr, this function replaces that | |
attribute and returns it; otherwise the function returns a \link | |
QDomNode::isNull() null attribute\endlink. | |
\sa attributeNodeNS() setAttributeNS() setAttributeNode() | |
*/ | |
QDomAttr QDomElement::setAttributeNodeNS(const QDomAttr& newAttr) | |
{ | |
if (!impl) | |
return QDomAttr(); | |
return QDomAttr(IMPL->setAttributeNodeNS(((QDomAttrPrivate*)newAttr.impl))); | |
} | |
/*! | |
Returns a QDomNodeList containing all descendants of this element | |
with local name \a localName and namespace URI \a nsURI encountered | |
during a preorder traversal of the element subtree with this element | |
as its root. The order of the elements in the returned list is the | |
order they are encountered during the preorder traversal. | |
\sa elementsByTagName() QDomDocument::elementsByTagNameNS() | |
*/ | |
QDomNodeList QDomElement::elementsByTagNameNS(const QString& nsURI, const QString& localName) const | |
{ | |
return QDomNodeList(new QDomNodeListPrivate(impl, nsURI, localName)); | |
} | |
/*! | |
Returns true if this element has an attribute with the local name | |
\a localName and the namespace URI \a nsURI; otherwise returns | |
false. | |
*/ | |
bool QDomElement::hasAttributeNS(const QString& nsURI, const QString& localName) const | |
{ | |
if (!impl) | |
return false; | |
return IMPL->hasAttributeNS(nsURI, localName); | |
} | |
/*! | |
Returns the element's text or an empty string. | |
Example: | |
\snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 13 | |
The function text() of the QDomElement for the \c{<h1>} tag, | |
will return the following text: | |
\snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 14 | |
Comments are ignored by this function. It only evaluates QDomText | |
and QDomCDATASection objects. | |
*/ | |
QString QDomElement::text() const | |
{ | |
if (!impl) | |
return QString(); | |
return IMPL->text(); | |
} | |
#undef IMPL | |
/************************************************************** | |
* | |
* QDomTextPrivate | |
* | |
**************************************************************/ | |
QDomTextPrivate::QDomTextPrivate(QDomDocumentPrivate* d, QDomNodePrivate* parent, const QString& val) | |
: QDomCharacterDataPrivate(d, parent, val) | |
{ | |
name = QLatin1String("#text"); | |
} | |
QDomTextPrivate::QDomTextPrivate(QDomTextPrivate* n, bool deep) | |
: QDomCharacterDataPrivate(n, deep) | |
{ | |
} | |
QDomNodePrivate* QDomTextPrivate::cloneNode(bool deep) | |
{ | |
QDomNodePrivate* p = new QDomTextPrivate(this, deep); | |
// We are not interested in this node | |
p->ref.deref(); | |
return p; | |
} | |
QDomTextPrivate* QDomTextPrivate::splitText(int offset) | |
{ | |
if (!parent()) { | |
qWarning("QDomText::splitText The node has no parent. So I can not split"); | |
return 0; | |
} | |
QDomTextPrivate* t = new QDomTextPrivate(ownerDocument(), 0, value.mid(offset)); | |
value.truncate(offset); | |
parent()->insertAfter(t, this); | |
return t; | |
} | |
void QDomTextPrivate::save(QTextStream& s, int, int) const | |
{ | |
QDomTextPrivate *that = const_cast<QDomTextPrivate*>(this); | |
s << encodeText(value, s, !(that->parent() && that->parent()->isElement()), false, true); | |
} | |
/************************************************************** | |
* | |
* QDomText | |
* | |
**************************************************************/ | |
#define IMPL ((QDomTextPrivate*)impl) | |
/*! | |
\class QDomText | |
\reentrant | |
\brief The QDomText class represents text data in the parsed XML document. | |
\inmodule QtXml | |
\ingroup xml-tools | |
You can split the text in a QDomText object over two QDomText | |
objecs with splitText(). | |
For further information about the Document Object Model see | |
\l{http://www.w3.org/TR/REC-DOM-Level-1/}{Level 1} and | |
\l{http://www.w3.org/TR/DOM-Level-2-Core/}{Level 2 Core}. | |
For a more general introduction of the DOM implementation see the | |
QDomDocument documentation. | |
*/ | |
/*! | |
Constructs an empty QDomText object. | |
To construct a QDomText with content, use QDomDocument::createTextNode(). | |
*/ | |
QDomText::QDomText() | |
: QDomCharacterData() | |
{ | |
} | |
/*! | |
Constructs a copy of \a x. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomText::QDomText(const QDomText& x) | |
: QDomCharacterData(x) | |
{ | |
} | |
QDomText::QDomText(QDomTextPrivate* n) | |
: QDomCharacterData(n) | |
{ | |
} | |
/*! | |
Assigns \a x to this DOM text. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomText& QDomText::operator= (const QDomText& x) | |
{ | |
return (QDomText&) QDomNode::operator=(x); | |
} | |
/*! | |
\fn QDomNode::NodeType QDomText::nodeType() const | |
Returns \c TextNode. | |
*/ | |
/*! | |
Splits this DOM text object into two QDomText objects. This object | |
keeps its first \a offset characters and the second (newly | |
created) object is inserted into the document tree after this | |
object with the remaining characters. | |
The function returns the newly created object. | |
\sa QDomNode::normalize() | |
*/ | |
QDomText QDomText::splitText(int offset) | |
{ | |
if (!impl) | |
return QDomText(); | |
return QDomText(IMPL->splitText(offset)); | |
} | |
#undef IMPL | |
/************************************************************** | |
* | |
* QDomCommentPrivate | |
* | |
**************************************************************/ | |
QDomCommentPrivate::QDomCommentPrivate(QDomDocumentPrivate* d, QDomNodePrivate* parent, const QString& val) | |
: QDomCharacterDataPrivate(d, parent, val) | |
{ | |
name = QLatin1String("#comment"); | |
} | |
QDomCommentPrivate::QDomCommentPrivate(QDomCommentPrivate* n, bool deep) | |
: QDomCharacterDataPrivate(n, deep) | |
{ | |
} | |
QDomNodePrivate* QDomCommentPrivate::cloneNode(bool deep) | |
{ | |
QDomNodePrivate* p = new QDomCommentPrivate(this, deep); | |
// We are not interested in this node | |
p->ref.deref(); | |
return p; | |
} | |
void QDomCommentPrivate::save(QTextStream& s, int depth, int indent) const | |
{ | |
/* We don't output whitespace if we would pollute a text node. */ | |
if (!(prev && prev->isText())) | |
s << QString(indent < 1 ? 0 : depth * indent, QLatin1Char(' ')); | |
s << "<!--" << value; | |
if (value.endsWith(QLatin1Char('-'))) | |
s << ' '; // Ensures that XML comment doesn't end with ---> | |
s << "-->"; | |
if (!(next && next->isText())) | |
s << endl; | |
} | |
/************************************************************** | |
* | |
* QDomComment | |
* | |
**************************************************************/ | |
/*! | |
\class QDomComment | |
\reentrant | |
\brief The QDomComment class represents an XML comment. | |
\inmodule QtXml | |
\ingroup xml-tools | |
A comment in the parsed XML such as this: | |
\snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 15 | |
is represented by QDomComment objects in the parsed Dom tree. | |
For further information about the Document Object Model see | |
\l{http://www.w3.org/TR/REC-DOM-Level-1/} and | |
\l{http://www.w3.org/TR/DOM-Level-2-Core/}. | |
For a more general introduction of the DOM implementation see the | |
QDomDocument documentation. | |
*/ | |
/*! | |
Constructs an empty comment. To construct a comment with content, | |
use the QDomDocument::createComment() function. | |
*/ | |
QDomComment::QDomComment() | |
: QDomCharacterData() | |
{ | |
} | |
/*! | |
Constructs a copy of \a x. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomComment::QDomComment(const QDomComment& x) | |
: QDomCharacterData(x) | |
{ | |
} | |
QDomComment::QDomComment(QDomCommentPrivate* n) | |
: QDomCharacterData(n) | |
{ | |
} | |
/*! | |
Assigns \a x to this DOM comment. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomComment& QDomComment::operator= (const QDomComment& x) | |
{ | |
return (QDomComment&) QDomNode::operator=(x); | |
} | |
/*! | |
\fn QDomNode::NodeType QDomComment::nodeType() const | |
Returns \c CommentNode. | |
*/ | |
/************************************************************** | |
* | |
* QDomCDATASectionPrivate | |
* | |
**************************************************************/ | |
QDomCDATASectionPrivate::QDomCDATASectionPrivate(QDomDocumentPrivate* d, QDomNodePrivate* parent, | |
const QString& val) | |
: QDomTextPrivate(d, parent, val) | |
{ | |
name = QLatin1String("#cdata-section"); | |
} | |
QDomCDATASectionPrivate::QDomCDATASectionPrivate(QDomCDATASectionPrivate* n, bool deep) | |
: QDomTextPrivate(n, deep) | |
{ | |
} | |
QDomNodePrivate* QDomCDATASectionPrivate::cloneNode(bool deep) | |
{ | |
QDomNodePrivate* p = new QDomCDATASectionPrivate(this, deep); | |
// We are not interested in this node | |
p->ref.deref(); | |
return p; | |
} | |
void QDomCDATASectionPrivate::save(QTextStream& s, int, int) const | |
{ | |
// ### How do we escape "]]>" ? | |
// "]]>" is not allowed; so there should be none in value anyway | |
s << "<![CDATA[" << value << "]]>"; | |
} | |
/************************************************************** | |
* | |
* QDomCDATASection | |
* | |
**************************************************************/ | |
/*! | |
\class QDomCDATASection | |
\reentrant | |
\brief The QDomCDATASection class represents an XML CDATA section. | |
\inmodule QtXml | |
\ingroup xml-tools | |
CDATA sections are used to escape blocks of text containing | |
characters that would otherwise be regarded as markup. The only | |
delimiter that is recognized in a CDATA section is the "]]>" | |
string that terminates the CDATA section. CDATA sections cannot be | |
nested. Their primary purpose is for including material such as | |
XML fragments, without needing to escape all the delimiters. | |
Adjacent QDomCDATASection nodes are not merged by the | |
QDomNode::normalize() function. | |
For further information about the Document Object Model see | |
\l{http://www.w3.org/TR/REC-DOM-Level-1/} and | |
\l{http://www.w3.org/TR/DOM-Level-2-Core/}. | |
For a more general introduction of the DOM implementation see the | |
QDomDocument documentation. | |
*/ | |
/*! | |
Constructs an empty CDATA section. To create a CDATA section with | |
content, use the QDomDocument::createCDATASection() function. | |
*/ | |
QDomCDATASection::QDomCDATASection() | |
: QDomText() | |
{ | |
} | |
/*! | |
Constructs a copy of \a x. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomCDATASection::QDomCDATASection(const QDomCDATASection& x) | |
: QDomText(x) | |
{ | |
} | |
QDomCDATASection::QDomCDATASection(QDomCDATASectionPrivate* n) | |
: QDomText(n) | |
{ | |
} | |
/*! | |
Assigns \a x to this CDATA section. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomCDATASection& QDomCDATASection::operator= (const QDomCDATASection& x) | |
{ | |
return (QDomCDATASection&) QDomNode::operator=(x); | |
} | |
/*! | |
\fn QDomNode::NodeType QDomCDATASection::nodeType() const | |
Returns \c CDATASection. | |
*/ | |
/************************************************************** | |
* | |
* QDomNotationPrivate | |
* | |
**************************************************************/ | |
QDomNotationPrivate::QDomNotationPrivate(QDomDocumentPrivate* d, QDomNodePrivate* parent, | |
const QString& aname, | |
const QString& pub, const QString& sys) | |
: QDomNodePrivate(d, parent) | |
{ | |
name = aname; | |
m_pub = pub; | |
m_sys = sys; | |
} | |
QDomNotationPrivate::QDomNotationPrivate(QDomNotationPrivate* n, bool deep) | |
: QDomNodePrivate(n, deep) | |
{ | |
m_sys = n->m_sys; | |
m_pub = n->m_pub; | |
} | |
QDomNodePrivate* QDomNotationPrivate::cloneNode(bool deep) | |
{ | |
QDomNodePrivate* p = new QDomNotationPrivate(this, deep); | |
// We are not interested in this node | |
p->ref.deref(); | |
return p; | |
} | |
void QDomNotationPrivate::save(QTextStream& s, int, int) const | |
{ | |
s << "<!NOTATION " << name << ' '; | |
if (!m_pub.isNull()) { | |
s << "PUBLIC " << quotedValue(m_pub); | |
if (!m_sys.isNull()) | |
s << ' ' << quotedValue(m_sys); | |
} else { | |
s << "SYSTEM " << quotedValue(m_sys); | |
} | |
s << '>' << endl; | |
} | |
/************************************************************** | |
* | |
* QDomNotation | |
* | |
**************************************************************/ | |
#define IMPL ((QDomNotationPrivate*)impl) | |
/*! | |
\class QDomNotation | |
\reentrant | |
\brief The QDomNotation class represents an XML notation. | |
\inmodule QtXml | |
\ingroup xml-tools | |
A notation either declares, by name, the format of an unparsed | |
entity (see section 4.7 of the XML 1.0 specification), or is used | |
for formal declaration of processing instruction targets (see | |
section 2.6 of the XML 1.0 specification). | |
DOM does not support editing notation nodes; they are therefore | |
read-only. | |
A notation node does not have any parent. | |
You can retrieve the publicId() and systemId() from a notation | |
node. | |
For further information about the Document Object Model see | |
\l{http://www.w3.org/TR/REC-DOM-Level-1/}{Level 1} and | |
\l{http://www.w3.org/TR/DOM-Level-2-Core/}{Level 2 Core}. | |
For a more general introduction of the DOM implementation see the | |
QDomDocument documentation. | |
*/ | |
/*! | |
Constructor. | |
*/ | |
QDomNotation::QDomNotation() | |
: QDomNode() | |
{ | |
} | |
/*! | |
Constructs a copy of \a x. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomNotation::QDomNotation(const QDomNotation& x) | |
: QDomNode(x) | |
{ | |
} | |
QDomNotation::QDomNotation(QDomNotationPrivate* n) | |
: QDomNode(n) | |
{ | |
} | |
/*! | |
Assigns \a x to this DOM notation. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomNotation& QDomNotation::operator= (const QDomNotation& x) | |
{ | |
return (QDomNotation&) QDomNode::operator=(x); | |
} | |
/*! | |
\fn QDomNode::NodeType QDomNotation::nodeType() const | |
Returns \c NotationNode. | |
*/ | |
/*! | |
Returns the public identifier of this notation. | |
*/ | |
QString QDomNotation::publicId() const | |
{ | |
if (!impl) | |
return QString(); | |
return IMPL->m_pub; | |
} | |
/*! | |
Returns the system identifier of this notation. | |
*/ | |
QString QDomNotation::systemId() const | |
{ | |
if (!impl) | |
return QString(); | |
return IMPL->m_sys; | |
} | |
#undef IMPL | |
/************************************************************** | |
* | |
* QDomEntityPrivate | |
* | |
**************************************************************/ | |
QDomEntityPrivate::QDomEntityPrivate(QDomDocumentPrivate* d, QDomNodePrivate* parent, | |
const QString& aname, | |
const QString& pub, const QString& sys, const QString& notation) | |
: QDomNodePrivate(d, parent) | |
{ | |
name = aname; | |
m_pub = pub; | |
m_sys = sys; | |
m_notationName = notation; | |
} | |
QDomEntityPrivate::QDomEntityPrivate(QDomEntityPrivate* n, bool deep) | |
: QDomNodePrivate(n, deep) | |
{ | |
m_sys = n->m_sys; | |
m_pub = n->m_pub; | |
m_notationName = n->m_notationName; | |
} | |
QDomNodePrivate* QDomEntityPrivate::cloneNode(bool deep) | |
{ | |
QDomNodePrivate* p = new QDomEntityPrivate(this, deep); | |
// We are not interested in this node | |
p->ref.deref(); | |
return p; | |
} | |
/* | |
Encode an entity value upon saving. | |
*/ | |
static QByteArray encodeEntity(const QByteArray& str) | |
{ | |
QByteArray tmp(str); | |
uint len = tmp.size(); | |
uint i = 0; | |
const char* d = tmp.data(); | |
while (i < len) { | |
if (d[i] == '%'){ | |
tmp.replace(i, 1, "<"); | |
d = tmp; | |
len += 4; | |
i += 5; | |
} | |
else if (d[i] == '"') { | |
tmp.replace(i, 1, """); | |
d = tmp; | |
len += 4; | |
i += 5; | |
} else if (d[i] == '&' && i + 1 < len && d[i+1] == '#') { | |
// Dont encode < or " or &custom;. | |
// Only encode character references | |
tmp.replace(i, 1, "&"); | |
d = tmp; | |
len += 4; | |
i += 5; | |
} else { | |
++i; | |
} | |
} | |
return tmp; | |
} | |
void QDomEntityPrivate::save(QTextStream& s, int, int) const | |
{ | |
QString _name = name; | |
if (_name.startsWith(QLatin1Char('%'))) | |
_name = QLatin1String("% ") + _name.mid(1); | |
if (m_sys.isNull() && m_pub.isNull()) { | |
s << "<!ENTITY " << _name << " \"" << encodeEntity(value.toUtf8()) << "\">" << endl; | |
} else { | |
s << "<!ENTITY " << _name << ' '; | |
if (m_pub.isNull()) { | |
s << "SYSTEM " << quotedValue(m_sys); | |
} else { | |
s << "PUBLIC " << quotedValue(m_pub) << ' ' << quotedValue(m_sys); | |
} | |
if (! m_notationName.isNull()) { | |
s << " NDATA " << m_notationName; | |
} | |
s << '>' << endl; | |
} | |
} | |
/************************************************************** | |
* | |
* QDomEntity | |
* | |
**************************************************************/ | |
#define IMPL ((QDomEntityPrivate*)impl) | |
/*! | |
\class QDomEntity | |
\reentrant | |
\brief The QDomEntity class represents an XML entity. | |
\inmodule QtXml | |
\ingroup xml-tools | |
This class represents an entity in an XML document, either parsed | |
or unparsed. Note that this models the entity itself not the | |
entity declaration. | |
DOM does not support editing entity nodes; if a user wants to make | |
changes to the contents of an entity, every related | |
QDomEntityReference node must be replaced in the DOM tree by a | |
clone of the entity's contents, and then the desired changes must | |
be made to each of the clones instead. All the descendants of an | |
entity node are read-only. | |
An entity node does not have any parent. | |
You can access the entity's publicId(), systemId() and | |
notationName() when available. | |
For further information about the Document Object Model see | |
\l{http://www.w3.org/TR/REC-DOM-Level-1/}{Level 1} and | |
\l{http://www.w3.org/TR/DOM-Level-2-Core/}{Level 2 Core}. | |
For a more general introduction of the DOM implementation see the | |
QDomDocument documentation. | |
*/ | |
/*! | |
Constructs an empty entity. | |
*/ | |
QDomEntity::QDomEntity() | |
: QDomNode() | |
{ | |
} | |
/*! | |
Constructs a copy of \a x. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomEntity::QDomEntity(const QDomEntity& x) | |
: QDomNode(x) | |
{ | |
} | |
QDomEntity::QDomEntity(QDomEntityPrivate* n) | |
: QDomNode(n) | |
{ | |
} | |
/*! | |
Assigns \a x to this DOM entity. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomEntity& QDomEntity::operator= (const QDomEntity& x) | |
{ | |
return (QDomEntity&) QDomNode::operator=(x); | |
} | |
/*! | |
\fn QDomNode::NodeType QDomEntity::nodeType() const | |
Returns \c EntityNode. | |
*/ | |
/*! | |
Returns the public identifier associated with this entity. If the | |
public identifier was not specified an empty string is returned. | |
*/ | |
QString QDomEntity::publicId() const | |
{ | |
if (!impl) | |
return QString(); | |
return IMPL->m_pub; | |
} | |
/*! | |
Returns the system identifier associated with this entity. If the | |
system identifier was not specified an empty string is returned. | |
*/ | |
QString QDomEntity::systemId() const | |
{ | |
if (!impl) | |
return QString(); | |
return IMPL->m_sys; | |
} | |
/*! | |
For unparsed entities this function returns the name of the | |
notation for the entity. For parsed entities this function returns | |
an empty string. | |
*/ | |
QString QDomEntity::notationName() const | |
{ | |
if (!impl) | |
return QString(); | |
return IMPL->m_notationName; | |
} | |
#undef IMPL | |
/************************************************************** | |
* | |
* QDomEntityReferencePrivate | |
* | |
**************************************************************/ | |
QDomEntityReferencePrivate::QDomEntityReferencePrivate(QDomDocumentPrivate* d, QDomNodePrivate* parent, const QString& aname) | |
: QDomNodePrivate(d, parent) | |
{ | |
name = aname; | |
} | |
QDomEntityReferencePrivate::QDomEntityReferencePrivate(QDomNodePrivate* n, bool deep) | |
: QDomNodePrivate(n, deep) | |
{ | |
} | |
QDomNodePrivate* QDomEntityReferencePrivate::cloneNode(bool deep) | |
{ | |
QDomNodePrivate* p = new QDomEntityReferencePrivate(this, deep); | |
// We are not interested in this node | |
p->ref.deref(); | |
return p; | |
} | |
void QDomEntityReferencePrivate::save(QTextStream& s, int, int) const | |
{ | |
s << '&' << name << ';'; | |
} | |
/************************************************************** | |
* | |
* QDomEntityReference | |
* | |
**************************************************************/ | |
/*! | |
\class QDomEntityReference | |
\reentrant | |
\brief The QDomEntityReference class represents an XML entity reference. | |
\inmodule QtXml | |
\ingroup xml-tools | |
A QDomEntityReference object may be inserted into the DOM tree | |
when an entity reference is in the source document, or when the | |
user wishes to insert an entity reference. | |
Note that character references and references to predefined | |
entities are expanded by the XML processor so that characters are | |
represented by their Unicode equivalent rather than by an entity | |
reference. | |
Moreover, the XML processor may completely expand references to | |
entities while building the DOM tree, instead of providing | |
QDomEntityReference objects. | |
If it does provide such objects, then for a given entity reference | |
node, it may be that there is no entity node representing the | |
referenced entity; but if such an entity exists, then the child | |
list of the entity reference node is the same as that of the | |
entity node. As with the entity node, all descendants of the | |
entity reference are read-only. | |
For further information about the Document Object Model see | |
\l{http://www.w3.org/TR/REC-DOM-Level-1/}{Level 1} and | |
\l{http://www.w3.org/TR/DOM-Level-2-Core/}{Level 2 Core}. | |
For a more general introduction of the DOM implementation see the | |
QDomDocument documentation. | |
*/ | |
/*! | |
Constructs an empty entity reference. Use | |
QDomDocument::createEntityReference() to create a entity reference | |
with content. | |
*/ | |
QDomEntityReference::QDomEntityReference() | |
: QDomNode() | |
{ | |
} | |
/*! | |
Constructs a copy of \a x. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomEntityReference::QDomEntityReference(const QDomEntityReference& x) | |
: QDomNode(x) | |
{ | |
} | |
QDomEntityReference::QDomEntityReference(QDomEntityReferencePrivate* n) | |
: QDomNode(n) | |
{ | |
} | |
/*! | |
Assigns \a x to this entity reference. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomEntityReference& QDomEntityReference::operator= (const QDomEntityReference& x) | |
{ | |
return (QDomEntityReference&) QDomNode::operator=(x); | |
} | |
/*! | |
\fn QDomNode::NodeType QDomEntityReference::nodeType() const | |
Returns \c EntityReference. | |
*/ | |
/************************************************************** | |
* | |
* QDomProcessingInstructionPrivate | |
* | |
**************************************************************/ | |
QDomProcessingInstructionPrivate::QDomProcessingInstructionPrivate(QDomDocumentPrivate* d, | |
QDomNodePrivate* parent, const QString& target, const QString& data) | |
: QDomNodePrivate(d, parent) | |
{ | |
name = target; | |
value = data; | |
} | |
QDomProcessingInstructionPrivate::QDomProcessingInstructionPrivate(QDomProcessingInstructionPrivate* n, bool deep) | |
: QDomNodePrivate(n, deep) | |
{ | |
} | |
QDomNodePrivate* QDomProcessingInstructionPrivate::cloneNode(bool deep) | |
{ | |
QDomNodePrivate* p = new QDomProcessingInstructionPrivate(this, deep); | |
// We are not interested in this node | |
p->ref.deref(); | |
return p; | |
} | |
void QDomProcessingInstructionPrivate::save(QTextStream& s, int, int) const | |
{ | |
s << "<?" << name << ' ' << value << "?>" << endl; | |
} | |
/************************************************************** | |
* | |
* QDomProcessingInstruction | |
* | |
**************************************************************/ | |
/*! | |
\class QDomProcessingInstruction | |
\reentrant | |
\brief The QDomProcessingInstruction class represents an XML processing | |
instruction. | |
\inmodule QtXml | |
\ingroup xml-tools | |
Processing instructions are used in XML to keep processor-specific | |
information in the text of the document. | |
The XML declaration that appears at the top of an XML document, | |
typically \tt{<?xml version='1.0' encoding='UTF-8'?>}, is treated by QDom as a | |
processing instruction. This is unfortunate, since the XML declaration is | |
not a processing instruction; among other differences, it cannot be | |
inserted into a document anywhere but on the first line. | |
Do not use this function to create an xml declaration, since although it | |
has the same syntax as a processing instruction, it isn't, and might not | |
be treated by QDom as such. | |
The content of the processing instruction is retrieved with data() | |
and set with setData(). The processing instruction's target is | |
retrieved with target(). | |
For further information about the Document Object Model see | |
\l{http://www.w3.org/TR/REC-DOM-Level-1/}{Level 1} and | |
\l{http://www.w3.org/TR/DOM-Level-2-Core/}{Level 2 Core}. | |
For a more general introduction of the DOM implementation see the | |
QDomDocument documentation. | |
*/ | |
/*! | |
Constructs an empty processing instruction. Use | |
QDomDocument::createProcessingInstruction() to create a processing | |
instruction with content. | |
*/ | |
QDomProcessingInstruction::QDomProcessingInstruction() | |
: QDomNode() | |
{ | |
} | |
/*! | |
Constructs a copy of \a x. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomProcessingInstruction::QDomProcessingInstruction(const QDomProcessingInstruction& x) | |
: QDomNode(x) | |
{ | |
} | |
QDomProcessingInstruction::QDomProcessingInstruction(QDomProcessingInstructionPrivate* n) | |
: QDomNode(n) | |
{ | |
} | |
/*! | |
Assigns \a x to this processing instruction. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomProcessingInstruction& QDomProcessingInstruction::operator= (const QDomProcessingInstruction& x) | |
{ | |
return (QDomProcessingInstruction&) QDomNode::operator=(x); | |
} | |
/*! | |
\fn QDomNode::NodeType QDomProcessingInstruction::nodeType() const | |
Returns \c ProcessingInstructionNode. | |
*/ | |
/*! | |
Returns the target of this processing instruction. | |
\sa data() | |
*/ | |
QString QDomProcessingInstruction::target() const | |
{ | |
if (!impl) | |
return QString(); | |
return impl->nodeName(); | |
} | |
/*! | |
Returns the content of this processing instruction. | |
\sa setData() target() | |
*/ | |
QString QDomProcessingInstruction::data() const | |
{ | |
if (!impl) | |
return QString(); | |
return impl->nodeValue(); | |
} | |
/*! | |
Sets the data contained in the processing instruction to \a d. | |
\sa data() | |
*/ | |
void QDomProcessingInstruction::setData(const QString& d) | |
{ | |
if (!impl) | |
return; | |
impl->setNodeValue(d); | |
} | |
/************************************************************** | |
* | |
* QDomDocumentPrivate | |
* | |
**************************************************************/ | |
QDomDocumentPrivate::QDomDocumentPrivate() | |
: QDomNodePrivate(0), | |
impl(new QDomImplementationPrivate), | |
nodeListTime(1) | |
{ | |
type = new QDomDocumentTypePrivate(this, this); | |
type->ref.deref(); | |
name = QLatin1String("#document"); | |
} | |
QDomDocumentPrivate::QDomDocumentPrivate(const QString& aname) | |
: QDomNodePrivate(0), | |
impl(new QDomImplementationPrivate), | |
nodeListTime(1) | |
{ | |
type = new QDomDocumentTypePrivate(this, this); | |
type->ref.deref(); | |
type->name = aname; | |
name = QLatin1String("#document"); | |
} | |
QDomDocumentPrivate::QDomDocumentPrivate(QDomDocumentTypePrivate* dt) | |
: QDomNodePrivate(0), | |
impl(new QDomImplementationPrivate), | |
nodeListTime(1) | |
{ | |
if (dt != 0) { | |
type = dt; | |
} else { | |
type = new QDomDocumentTypePrivate(this, this); | |
type->ref.deref(); | |
} | |
name = QLatin1String("#document"); | |
} | |
QDomDocumentPrivate::QDomDocumentPrivate(QDomDocumentPrivate* n, bool deep) | |
: QDomNodePrivate(n, deep), | |
impl(n->impl->clone()), | |
nodeListTime(1) | |
{ | |
type = static_cast<QDomDocumentTypePrivate*>(n->type->cloneNode()); | |
type->setParent(this); | |
} | |
QDomDocumentPrivate::~QDomDocumentPrivate() | |
{ | |
} | |
void QDomDocumentPrivate::clear() | |
{ | |
impl.reset(); | |
type.reset(); | |
QDomNodePrivate::clear(); | |
} | |
static void initializeReader(QXmlSimpleReader &reader, bool namespaceProcessing) | |
{ | |
reader.setFeature(QLatin1String("http://xml.org/sax/features/namespaces"), namespaceProcessing); | |
reader.setFeature(QLatin1String("http://xml.org/sax/features/namespace-prefixes"), !namespaceProcessing); | |
reader.setFeature(QLatin1String("http://trolltech.com/xml/features/report-whitespace-only-CharData"), false); // Shouldn't change in Qt 4 | |
} | |
bool QDomDocumentPrivate::setContent(QXmlInputSource *source, bool namespaceProcessing, QString *errorMsg, int *errorLine, int *errorColumn) | |
{ | |
QXmlSimpleReader reader; | |
initializeReader(reader, namespaceProcessing); | |
return setContent(source, &reader, errorMsg, errorLine, errorColumn); | |
} | |
bool QDomDocumentPrivate::setContent(QXmlInputSource *source, QXmlReader *reader, QString *errorMsg, int *errorLine, int *errorColumn) | |
{ | |
clear(); | |
impl = new QDomImplementationPrivate; | |
type = new QDomDocumentTypePrivate(this, this); | |
type->ref.deref(); | |
bool namespaceProcessing = reader->feature(QLatin1String("http://xml.org/sax/features/namespaces")) | |
&& !reader->feature(QLatin1String("http://xml.org/sax/features/namespace-prefixes")); | |
QDomHandler hnd(this, namespaceProcessing); | |
reader->setContentHandler(&hnd); | |
reader->setErrorHandler(&hnd); | |
reader->setLexicalHandler(&hnd); | |
reader->setDeclHandler(&hnd); | |
reader->setDTDHandler(&hnd); | |
if (!reader->parse(source)) { | |
if (errorMsg) | |
*errorMsg = hnd.errorMsg; | |
if (errorLine) | |
*errorLine = hnd.errorLine; | |
if (errorColumn) | |
*errorColumn = hnd.errorColumn; | |
return false; | |
} | |
return true; | |
} | |
QDomNodePrivate* QDomDocumentPrivate::cloneNode(bool deep) | |
{ | |
QDomNodePrivate *p = new QDomDocumentPrivate(this, deep); | |
// We are not interested in this node | |
p->ref.deref(); | |
return p; | |
} | |
QDomElementPrivate* QDomDocumentPrivate::documentElement() | |
{ | |
QDomNodePrivate *p = first; | |
while (p && !p->isElement()) | |
p = p->next; | |
return static_cast<QDomElementPrivate *>(p); | |
} | |
QDomElementPrivate* QDomDocumentPrivate::createElement(const QString &tagName) | |
{ | |
bool ok; | |
QString fixedName = fixedXmlName(tagName, &ok); | |
if (!ok) | |
return 0; | |
QDomElementPrivate *e = new QDomElementPrivate(this, 0, fixedName); | |
e->ref.deref(); | |
return e; | |
} | |
QDomElementPrivate* QDomDocumentPrivate::createElementNS(const QString &nsURI, const QString &qName) | |
{ | |
bool ok; | |
QString fixedName = fixedXmlName(qName, &ok, true); | |
if (!ok) | |
return 0; | |
QDomElementPrivate *e = new QDomElementPrivate(this, 0, nsURI, fixedName); | |
e->ref.deref(); | |
return e; | |
} | |
QDomDocumentFragmentPrivate* QDomDocumentPrivate::createDocumentFragment() | |
{ | |
QDomDocumentFragmentPrivate *f = new QDomDocumentFragmentPrivate(this, (QDomNodePrivate*)0); | |
f->ref.deref(); | |
return f; | |
} | |
QDomTextPrivate* QDomDocumentPrivate::createTextNode(const QString &data) | |
{ | |
bool ok; | |
QString fixedData = fixedCharData(data, &ok); | |
if (!ok) | |
return 0; | |
QDomTextPrivate *t = new QDomTextPrivate(this, 0, fixedData); | |
t->ref.deref(); | |
return t; | |
} | |
QDomCommentPrivate* QDomDocumentPrivate::createComment(const QString &data) | |
{ | |
bool ok; | |
QString fixedData = fixedComment(data, &ok); | |
if (!ok) | |
return 0; | |
QDomCommentPrivate *c = new QDomCommentPrivate(this, 0, fixedData); | |
c->ref.deref(); | |
return c; | |
} | |
QDomCDATASectionPrivate* QDomDocumentPrivate::createCDATASection(const QString &data) | |
{ | |
bool ok; | |
QString fixedData = fixedCDataSection(data, &ok); | |
if (!ok) | |
return 0; | |
QDomCDATASectionPrivate *c = new QDomCDATASectionPrivate(this, 0, fixedData); | |
c->ref.deref(); | |
return c; | |
} | |
QDomProcessingInstructionPrivate* QDomDocumentPrivate::createProcessingInstruction(const QString &target, | |
const QString &data) | |
{ | |
bool ok; | |
QString fixedData = fixedPIData(data, &ok); | |
if (!ok) | |
return 0; | |
// [17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l')) | |
QString fixedTarget = fixedXmlName(target, &ok); | |
if (!ok) | |
return 0; | |
QDomProcessingInstructionPrivate *p = new QDomProcessingInstructionPrivate(this, 0, fixedTarget, fixedData); | |
p->ref.deref(); | |
return p; | |
} | |
QDomAttrPrivate* QDomDocumentPrivate::createAttribute(const QString &aname) | |
{ | |
bool ok; | |
QString fixedName = fixedXmlName(aname, &ok); | |
if (!ok) | |
return 0; | |
QDomAttrPrivate *a = new QDomAttrPrivate(this, 0, fixedName); | |
a->ref.deref(); | |
return a; | |
} | |
QDomAttrPrivate* QDomDocumentPrivate::createAttributeNS(const QString &nsURI, const QString &qName) | |
{ | |
bool ok; | |
QString fixedName = fixedXmlName(qName, &ok, true); | |
if (!ok) | |
return 0; | |
QDomAttrPrivate *a = new QDomAttrPrivate(this, 0, nsURI, fixedName); | |
a->ref.deref(); | |
return a; | |
} | |
QDomEntityReferencePrivate* QDomDocumentPrivate::createEntityReference(const QString &aname) | |
{ | |
bool ok; | |
QString fixedName = fixedXmlName(aname, &ok); | |
if (!ok) | |
return 0; | |
QDomEntityReferencePrivate *e = new QDomEntityReferencePrivate(this, 0, fixedName); | |
e->ref.deref(); | |
return e; | |
} | |
QDomNodePrivate* QDomDocumentPrivate::importNode(const QDomNodePrivate *importedNode, bool deep) | |
{ | |
QDomNodePrivate *node = 0; | |
switch (importedNode->nodeType()) { | |
case QDomNode::AttributeNode: | |
node = new QDomAttrPrivate((QDomAttrPrivate*)importedNode, true); | |
break; | |
case QDomNode::DocumentFragmentNode: | |
node = new QDomDocumentFragmentPrivate((QDomDocumentFragmentPrivate*)importedNode, deep); | |
break; | |
case QDomNode::ElementNode: | |
node = new QDomElementPrivate((QDomElementPrivate*)importedNode, deep); | |
break; | |
case QDomNode::EntityNode: | |
node = new QDomEntityPrivate((QDomEntityPrivate*)importedNode, deep); | |
break; | |
case QDomNode::EntityReferenceNode: | |
node = new QDomEntityReferencePrivate((QDomEntityReferencePrivate*)importedNode, false); | |
break; | |
case QDomNode::NotationNode: | |
node = new QDomNotationPrivate((QDomNotationPrivate*)importedNode, deep); | |
break; | |
case QDomNode::ProcessingInstructionNode: | |
node = new QDomProcessingInstructionPrivate((QDomProcessingInstructionPrivate*)importedNode, deep); | |
break; | |
case QDomNode::TextNode: | |
node = new QDomTextPrivate((QDomTextPrivate*)importedNode, deep); | |
break; | |
case QDomNode::CDATASectionNode: | |
node = new QDomCDATASectionPrivate((QDomCDATASectionPrivate*)importedNode, deep); | |
break; | |
case QDomNode::CommentNode: | |
node = new QDomCommentPrivate((QDomCommentPrivate*)importedNode, deep); | |
break; | |
default: | |
break; | |
} | |
if (node) { | |
node->setOwnerDocument(this); | |
// The QDomNode constructor increases the refcount, so deref first to | |
// keep refcount balanced. | |
node->ref.deref(); | |
} | |
return node; | |
} | |
void QDomDocumentPrivate::saveDocument(QTextStream& s, const int indent, QDomNode::EncodingPolicy encUsed) const | |
{ | |
const QDomNodePrivate* n = first; | |
if(encUsed == QDomNode::EncodingFromDocument) { | |
#ifndef QT_NO_TEXTCODEC | |
const QDomNodePrivate* n = first; | |
QTextCodec *codec = 0; | |
if (n && n->isProcessingInstruction() && n->nodeName() == QLatin1String("xml")) { | |
// we have an XML declaration | |
QString data = n->nodeValue(); | |
QRegExp encoding(QString::fromLatin1("encoding\\s*=\\s*((\"([^\"]*)\")|('([^']*)'))")); | |
encoding.indexIn(data); | |
QString enc = encoding.cap(3); | |
if (enc.isEmpty()) | |
enc = encoding.cap(5); | |
if (!enc.isEmpty()) | |
codec = QTextCodec::codecForName(enc.toLatin1().data()); | |
} | |
if (!codec) | |
codec = QTextCodec::codecForName("UTF-8"); | |
if (codec) | |
s.setCodec(codec); | |
#endif | |
bool doc = false; | |
while (n) { | |
if (!doc && !(n->isProcessingInstruction() && n->nodeName() == QLatin1String("xml"))) { | |
// save doctype after XML declaration | |
type->save(s, 0, indent); | |
doc = true; | |
} | |
n->save(s, 0, indent); | |
n = n->next; | |
} | |
} | |
else { | |
// Write out the XML declaration. | |
#ifdef QT_NO_TEXTCODEC | |
const QLatin1String codecName("iso-8859-1"); | |
#else | |
const QTextCodec *const codec = s.codec(); | |
Q_ASSERT_X(codec, "QDomNode::save()", "A codec must be specified in the text stream."); | |
const QByteArray codecName = codec->name(); | |
#endif | |
s << "<?xml version=\"1.0\" encoding=\"" | |
<< codecName | |
<< "\"?>\n"; | |
// Skip the first processing instruction by name "xml", if any such exists. | |
const QDomNodePrivate* startNode = n; | |
// First, we try to find the PI and sets the startNode to the one appearing after it. | |
while (n) { | |
if(n->isProcessingInstruction() && n->nodeName() == QLatin1String("xml")) { | |
startNode = n->next; | |
break; | |
} | |
else | |
n = n->next; | |
} | |
// Now we serialize all the nodes after the faked XML declaration(the PI). | |
while(startNode) { | |
startNode->save(s, 0, indent); | |
startNode = startNode->next; | |
} | |
} | |
} | |
/************************************************************** | |
* | |
* QDomDocument | |
* | |
**************************************************************/ | |
#define IMPL ((QDomDocumentPrivate*)impl) | |
/*! | |
\class QDomDocument | |
\reentrant | |
\brief The QDomDocument class represents an XML document. | |
\inmodule QtXml | |
\ingroup xml-tools | |
The QDomDocument class represents the entire XML document. | |
Conceptually, it is the root of the document tree, and provides | |
the primary access to the document's data. | |
Since elements, text nodes, comments, processing instructions, | |
etc., cannot exist outside the context of a document, the document | |
class also contains the factory functions needed to create these | |
objects. The node objects created have an ownerDocument() function | |
which associates them with the document within whose context they | |
were created. The DOM classes that will be used most often are | |
QDomNode, QDomDocument, QDomElement and QDomText. | |
The parsed XML is represented internally by a tree of objects that | |
can be accessed using the various QDom classes. All QDom classes | |
only \e reference objects in the internal tree. The internal | |
objects in the DOM tree will get deleted once the last QDom | |
object referencing them and the QDomDocument itself are deleted. | |
Creation of elements, text nodes, etc. is done using the various | |
factory functions provided in this class. Using the default | |
constructors of the QDom classes will only result in empty | |
objects that cannot be manipulated or inserted into the Document. | |
The QDomDocument class has several functions for creating document | |
data, for example, createElement(), createTextNode(), | |
createComment(), createCDATASection(), | |
createProcessingInstruction(), createAttribute() and | |
createEntityReference(). Some of these functions have versions | |
that support namespaces, i.e. createElementNS() and | |
createAttributeNS(). The createDocumentFragment() function is used | |
to hold parts of the document; this is useful for manipulating for | |
complex documents. | |
The entire content of the document is set with setContent(). This | |
function parses the string it is passed as an XML document and | |
creates the DOM tree that represents the document. The root | |
element is available using documentElement(). The textual | |
representation of the document can be obtained using toString(). | |
It is possible to insert a node from another document into the | |
document using importNode(). | |
You can obtain a list of all the elements that have a particular | |
tag with elementsByTagName() or with elementsByTagNameNS(). | |
The QDom classes are typically used as follows: | |
\snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 16 | |
Once \c doc and \c elem go out of scope, the whole internal tree | |
representing the XML document is deleted. | |
To create a document using DOM use code like this: | |
\snippet doc/src/snippets/code/src_xml_dom_qdom.cpp 17 | |
For further information about the Document Object Model see | |
the Document Object Model (DOM) | |
\l{http://www.w3.org/TR/REC-DOM-Level-1/}{Level 1} and | |
\l{http://www.w3.org/TR/DOM-Level-2-Core/}{Level 2 Core} | |
Specifications. | |
\sa {DOM Bookmarks Example}, {Simple DOM Model Example} | |
*/ | |
/*! | |
Constructs an empty document. | |
*/ | |
QDomDocument::QDomDocument() | |
{ | |
impl = 0; | |
} | |
/*! | |
Creates a document and sets the name of the document type to \a | |
name. | |
*/ | |
QDomDocument::QDomDocument(const QString& name) | |
{ | |
// We take over ownership | |
impl = new QDomDocumentPrivate(name); | |
} | |
/*! | |
Creates a document with the document type \a doctype. | |
\sa QDomImplementation::createDocumentType() | |
*/ | |
QDomDocument::QDomDocument(const QDomDocumentType& doctype) | |
{ | |
impl = new QDomDocumentPrivate((QDomDocumentTypePrivate*)(doctype.impl)); | |
} | |
/*! | |
Constructs a copy of \a x. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomDocument::QDomDocument(const QDomDocument& x) | |
: QDomNode(x) | |
{ | |
} | |
QDomDocument::QDomDocument(QDomDocumentPrivate* x) | |
: QDomNode(x) | |
{ | |
} | |
/*! | |
Assigns \a x to this DOM document. | |
The data of the copy is shared (shallow copy): modifying one node | |
will also change the other. If you want to make a deep copy, use | |
cloneNode(). | |
*/ | |
QDomDocument& QDomDocument::operator= (const QDomDocument& x) | |
{ | |
return (QDomDocument&) QDomNode::operator=(x); | |
} | |
/*! | |
Destroys the object and frees its resources. | |
*/ | |
QDomDocument::~QDomDocument() | |
{ | |
} | |
/*! | |
\overload | |
This function reads the XML document from the string \a text, returning | |
true if the content was successfully parsed; otherwise returns false. | |
Since \a text is already a Unicode string, no encoding detection | |
is done. | |
*/ | |
bool QDomDocument::setContent(const QString& text, bool namespaceProcessing, QString *errorMsg, int *errorLine, int *errorColumn) | |
{ | |
if (!impl) | |
impl = new QDomDocumentPrivate(); | |
QXmlInputSource source; | |
source.setData(text); | |
return IMPL->setContent(&source, namespaceProcessing, errorMsg, errorLine, errorColumn); | |
} | |
/*! | |
\nonreentrant | |
This function parses the XML document from the byte array \a | |
data and sets it as the content of the document. It tries to | |
detect the encoding of the document as required by the XML | |
specification. | |
If \a namespaceProcessing is true, the parser recognizes | |
namespaces in the XML file and sets the prefix name, local name | |
and namespace URI to appropriate values. If \a namespaceProcessing | |
is false, the parser does no namespace processing when it reads | |
the XML file. | |
If a parse error occurs, this function returns false and the error | |
message is placed in \c{*}\a{errorMsg}, the line number in | |
\c{*}\a{errorLine} and the column number in \c{*}\a{errorColumn} | |
(unless the associated pointer is set to 0); otherwise this | |
function returns true. The various error messages are described in | |
the QXmlParseException class documentation. Note that, if you | |
want to display these error messages to your application's users, | |
they will be displayed in English unless they are explicitly | |
translated. | |
If \a namespaceProcessing is true, the function QDomNode::prefix() | |
returns a string for all elements and attributes. It returns an | |
empty string if the element or attribute has no prefix. | |
Text nodes consisting only of whitespace are stripped and won't | |
appear in the QDomDocument. If this behavior is not desired, | |
one can use the setContent() overload that allows a QXmlReader to be | |
supplied. | |
If \a namespaceProcessing is false, the functions | |
QDomNode::prefix(), QDomNode::localName() and | |
QDomNode::namespaceURI() return an empty string. | |
Entity references are handled as follows: | |
\list | |
\o References to internal general entities and character entities occurring in the | |
content are included. The result is a QDomText node with the references replaced | |
by their corresponding entity values. | |
\o References to parameter entities occurring in the internal subset are included. | |
The result is a QDomDocumentType node which contains entity and notation declarations | |
with the references replaced by their corresponding entity values. | |
\o Any general parsed entity reference which is not defined in the internal subset and | |
which occurs in the content is represented as a QDomEntityReference node. | |
\o Any parsed entity reference which is not defined in the internal subset and which | |
occurs outside of the content is replaced with an empty string. | |
\o Any unparsed entity reference is replaced with an empty string. | |
\endlist | |
\sa QDomNode::namespaceURI() QDomNode::localName() | |
QDomNode::prefix() QString::isNull() QString::isEmpty() | |
*/ | |
bool QDomDocument::setContent(const QByteArray &data, bool namespaceProcessing, QString *errorMsg, int *errorLine, int *errorColumn) | |
{ | |
if (!impl) | |
impl = new QDomDocumentPrivate(); | |
QBuffer buf; | |
buf.setData(data); | |
QXmlInputSource source(&buf); | |
return IMPL->setContent(&source, namespaceProcessing, errorMsg, errorLine, errorColumn); | |
} | |
/*! | |
\overload | |
This function reads the XML document from the IO device \a dev, returning | |
true if the content was successfully parsed; otherwise returns false. | |
*/ | |
bool QDomDocument::setContent(QIODevice* dev, bool namespaceProcessing, QString *errorMsg, int *errorLine, int *errorColumn) | |
{ | |
if (!impl) | |
impl = new QDomDocumentPrivate(); | |
QXmlInputSource source(dev); | |
return IMPL->setContent(&source, namespaceProcessing, errorMsg, errorLine, errorColumn); | |
} | |
/*! | |
\overload | |
\since 4.5 | |
This function reads the XML document from the QXmlInputSource \a source, | |
returning true if the content was successfully parsed; otherwise returns false. | |
*/ | |
bool QDomDocument::setContent(QXmlInputSource *source, bool namespaceProcessing, QString *errorMsg, int *errorLine, int *errorColumn ) | |
{ | |
if (!impl) | |
impl = new QDomDocumentPrivate(); | |
QXmlSimpleReader reader; | |
initializeReader(reader, namespaceProcessing); | |
return IMPL->setContent(source, &reader, errorMsg, errorLine, errorColumn); | |
} | |
/*! | |
\overload | |
This function reads the XML document from the string \a text, returning | |
true if the content was successfully parsed; otherwise returns false. | |
Since \a text is already a Unicode string, no encoding detection | |
is performed. | |
No namespace processing is performed either. | |
*/ | |
bool QDomDocument::setContent(const QString& text, QString *errorMsg, int *errorLine, int *errorColumn) | |
{ | |
return setContent(text, false, errorMsg, errorLine, errorColumn); | |
} | |
/*! | |
\overload | |
This function reads the XML document from the byte array \a buffer, | |
returning true if the content was successfully parsed; otherwise returns | |
false. | |
No namespace processing is performed. | |
*/ | |
bool QDomDocument::setContent(const QByteArray& buffer, QString *errorMsg, int *errorLine, int *errorColumn ) | |
{ | |
return setContent(buffer, false, errorMsg, errorLine, errorColumn); | |
} | |
/*! | |
\overload | |
This function reads the XML document from the IO device \a dev, returning | |
true if the content was successfully parsed; otherwise returns false. | |
No namespace processing is performed. | |
*/ | |
bool QDomDocument::setContent(QIODevice* dev, QString *errorMsg, int *errorLine, int *errorColumn ) | |
{ | |
return setContent(dev, false, errorMsg, errorLine, errorColumn); | |
} | |
/*! | |
\overload | |
This function reads the XML document from the QXmlInputSource \a source and | |
parses it with the QXmlReader \a reader, returning true if the content was | |
successfully parsed; otherwise returns false. | |
This function doesn't change the features of the \a reader. If you want to | |
use certain features for parsing you can use this function to set up the | |
reader appropriately. | |
\sa QXmlSimpleReader | |
*/ | |
bool QDomDocument::setContent(QXmlInputSource *source, QXmlReader *reader, QString *errorMsg, int *errorLine, int *errorColumn ) | |
{ | |
if (!impl) | |
impl = new QDomDocumentPrivate(); | |
return IMPL->setContent(source, reader, errorMsg, errorLine, errorColumn); | |
} | |
/*! | |
Converts the parsed document back to its textual representation. | |
This function uses \a indent as the amount of space to indent | |
subelements. | |
If \a indent is -1, no whitespace at all is added. | |
*/ | |
QString QDomDocument::toString(int indent) const | |
{ | |
QString str; | |
QTextStream s(&str, QIODevice::WriteOnly); | |
save(s, indent); | |
return str; | |
} | |
/*! | |
Converts the parsed document back to its textual representation | |
and returns a QByteArray containing the data encoded as UTF-8. | |
This function uses \a indent as the amount of space to indent | |
subelements. | |
\sa toString() | |
*/ | |
QByteArray QDomDocument::toByteArray(int indent) const | |
{ | |
// ### if there is an encoding specified in the xml declaration, this | |
// encoding declaration should be changed to utf8 | |
return toString(indent).toUtf8(); | |
} | |
/*! | |
Returns the document type of this document. | |
*/ | |
QDomDocumentType QDomDocument::doctype() const | |
{ | |
if (!impl) | |
return QDomDocumentType(); | |
return QDomDocumentType(IMPL->doctype()); | |
} | |
/*! | |
Returns a QDomImplementation object. | |
*/ | |
QDomImplementation QDomDocument::implementation() const | |
{ | |
if (!impl) | |
return QDomImplementation(); | |
return QDomImplementation(IMPL->implementation()); | |
} | |
/*! | |
Returns the root element of the document. | |
*/ | |
QDomElement QDomDocument::documentElement() const | |
{ | |
if (!impl) | |
return QDomElement(); | |
return QDomElement(IMPL->documentElement()); | |
} | |
/*! | |
Creates a new element called \a tagName that can be inserted into | |
the DOM tree, e.g. using QDomNode::appendChild(). | |
If \a tagName is not a valid XML name, the behavior of this function is governed | |
by QDomImplementation::InvalidDataPolicy. | |
\sa createElementNS() QDomNode::appendChild() QDomNode::insertBefore() | |
QDomNode::insertAfter() | |
*/ | |
QDomElement QDomDocument::createElement(const QString& tagName) | |
{ | |
if (!impl) | |
impl = new QDomDocumentPrivate(); | |
return QDomElement(IMPL->createElement(tagName)); | |
} | |
/*! | |
Creates a new document fragment, that can be used to hold parts of | |
the document, e.g. when doing complex manipulations of the | |
document tree. | |
*/ | |
QDomDocumentFragment QDomDocument::createDocumentFragment() | |
{ | |
if (!impl) | |
impl = new QDomDocumentPrivate(); | |
return QDomDocumentFragment(IMPL->createDocumentFragment()); | |
} | |
/*! | |
Creates a text node for the string \a value that can be inserted | |
into the document tree, e.g. using QDomNode::appendChild(). | |
If \a value contains characters which cannot be stored as character | |
data of an XML document (even in the form of character references), the | |
behavior of this function is governed by QDomImplementation::InvalidDataPolicy. | |
\sa QDomNode::appendChild() QDomNode::insertBefore() QDomNode::insertAfter() | |
*/ | |
QDomText QDomDocument::createTextNode(const QString& value) | |
{ | |
if (!impl) | |
impl = new QDomDocumentPrivate(); | |
return QDomText(IMPL->createTextNode(value)); | |
} | |
/*! | |
Creates a new comment for the string \a value that can be inserted | |
into the document, e.g. using QDomNode::appendChild(). | |
If \a value contains characters which cannot be stored in an XML comment, | |
the behavior of this function is governed by QDomImplementation::InvalidDataPolicy. | |
\sa QDomNode::appendChild() QDomNode::insertBefore() QDomNode::insertAfter() | |
*/ | |
QDomComment QDomDocument::createComment(const QString& value) | |
{ | |
if (!impl) | |
impl = new QDomDocumentPrivate(); | |
return QDomComment(IMPL->createComment(value)); | |
} | |
/*! | |
Creates a new CDATA section for the string \a value that can be | |
inserted into the document, e.g. using QDomNode::appendChild(). | |
If \a value contains characters which cannot be stored in a CDATA section, | |
the behavior of this function is governed by | |
QDomImplementation::InvalidDataPolicy. | |
\sa QDomNode::appendChild() QDomNode::insertBefore() QDomNode::insertAfter() | |
*/ | |
QDomCDATASection QDomDocument::createCDATASection(const QString& value) | |
{ | |
if (!impl) | |
impl = new QDomDocumentPrivate(); | |
return QDomCDATASection(IMPL->createCDATASection(value)); | |
} | |
/*! | |
Creates a new processing instruction that can be inserted into the | |
document, e.g. using QDomNode::appendChild(). This function sets | |
the target for the processing instruction to \a target and the | |
data to \a data. | |
If \a target is not a valid XML name, or data if contains characters which cannot | |
appear in a processing instruction, the behavior of this function is governed by | |
QDomImplementation::InvalidDataPolicy. | |
\sa QDomNode::appendChild() QDomNode::insertBefore() QDomNode::insertAfter() | |
*/ | |
QDomProcessingInstruction QDomDocument::createProcessingInstruction(const QString& target, | |
const QString& data) | |
{ | |
if (!impl) | |
impl = new QDomDocumentPrivate(); | |
return QDomProcessingInstruction(IMPL->createProcessingInstruction(target, data)); | |
} | |
/*! | |
Creates a new attribute called \a name that can be inserted into | |
an element, e.g. using QDomElement::setAttributeNode(). | |
If \a name is not a valid XML name, the behavior of this function is governed by | |
QDomImplementation::InvalidDataPolicy. | |
\sa createAttributeNS() | |
*/ | |
QDomAttr QDomDocument::createAttribute(const QString& name) | |
{ | |
if (!impl) | |
impl = new QDomDocumentPrivate(); | |
return QDomAttr(IMPL->createAttribute(name)); | |
} | |
/*! | |
Creates a new entity reference called \a name that can be inserted | |
into the document, e.g. using QDomNode::appendChild(). | |
If \a name is not a valid XML name, the behavior of this function is governed by | |
QDomImplementation::InvalidDataPolicy. | |
\sa QDomNode::appendChild() QDomNode::insertBefore() QDomNode::insertAfter() | |
*/ | |
QDomEntityReference QDomDocument::createEntityReference(const QString& name) | |
{ | |
if (!impl) | |
impl = new QDomDocumentPrivate(); | |
return QDomEntityReference(IMPL->createEntityReference(name)); | |
} | |
/*! | |
Returns a QDomNodeList, that contains all the elements in the | |
document with the name \a tagname. The order of the node list is | |
the order they are encountered in a preorder traversal of the | |
element tree. | |
\sa elementsByTagNameNS() QDomElement::elementsByTagName() | |
*/ | |
QDomNodeList QDomDocument::elementsByTagName(const QString& tagname) const | |
{ | |
return QDomNodeList(new QDomNodeListPrivate(impl, tagname)); | |
} | |
/*! | |
Imports the node \a importedNode from another document to this | |
document. \a importedNode remains in the original document; this | |
function creates a copy that can be used within this document. | |
This function returns the imported node that belongs to this | |
document. The returned node has no parent. It is not possible to | |
import QDomDocument and QDomDocumentType nodes. In those cases | |
this function returns a \link QDomNode::isNull() null node\endlink. | |
If \a deep is true, this function imports not only the node \a | |
importedNode but its whole subtree; if it is false, only the \a | |
importedNode is imported. The argument \a deep has no effect on | |
QDomAttr and QDomEntityReference nodes, since the descendants of | |
QDomAttr nodes are always imported and those of | |
QDomEntityReference nodes are never imported. | |
The behavior of this function is slightly different depending on | |
the node types: | |
\table | |
\header \i Node Type \i Behavior | |
\row \i QDomAttr | |
\i The owner element is set to 0 and the specified flag is | |
set to true in the generated attribute. The whole subtree | |
of \a importedNode is always imported for attribute nodes: | |
\a deep has no effect. | |
\row \i QDomDocument | |
\i Document nodes cannot be imported. | |
\row \i QDomDocumentFragment | |
\i If \a deep is true, this function imports the whole | |
document fragment; otherwise it only generates an empty | |
document fragment. | |
\row \i QDomDocumentType | |
\i Document type nodes cannot be imported. | |
\row \i QDomElement | |
\i Attributes for which QDomAttr::specified() is true are | |
also imported, other attributes are not imported. If \a | |
deep is true, this function also imports the subtree of \a | |
importedNode; otherwise it imports only the element node | |
(and some attributes, see above). | |
\row \i QDomEntity | |
\i Entity nodes can be imported, but at the moment there is | |
no way to use them since the document type is read-only in | |
DOM level 2. | |
\row \i QDomEntityReference | |
\i Descendants of entity reference nodes are never imported: | |
\a deep has no effect. | |
\row \i QDomNotation | |
\i Notation nodes can be imported, but at the moment there is | |
no way to use them since the document type is read-only in | |
DOM level 2. | |
\row \i QDomProcessingInstruction | |
\i The target and value of the processing instruction is | |
copied to the new node. | |
\row \i QDomText | |
\i The text is copied to the new node. | |
\row \i QDomCDATASection | |
\i The text is copied to the new node. | |
\row \i QDomComment | |
\i The text is copied to the new node. | |
\endtable | |
\sa QDomElement::setAttribute() QDomNode::insertBefore() | |
QDomNode::insertAfter() QDomNode::replaceChild() QDomNode::removeChild() | |
QDomNode::appendChild() | |
*/ | |
QDomNode QDomDocument::importNode(const QDomNode& importedNode, bool deep) | |
{ | |
if (!impl) | |
impl = new QDomDocumentPrivate(); | |
return QDomNode(IMPL->importNode(importedNode.impl, deep)); | |
} | |
/*! | |
Creates a new element with namespace support that can be inserted | |
into the DOM tree. The name of the element is \a qName and the | |
namespace URI is \a nsURI. This function also sets | |
QDomNode::prefix() and QDomNode::localName() to appropriate values | |
(depending on \a qName). | |
If \a qName is an empty string, returns a null element regardless of | |
whether the invalid data policy is set. | |
\sa createElement() | |
*/ | |
QDomElement QDomDocument::createElementNS(const QString& nsURI, const QString& qName) | |
{ | |
if (!impl) | |
impl = new QDomDocumentPrivate(); | |
return QDomElement(IMPL->createElementNS(nsURI, qName)); | |
} | |
/*! | |
Creates a new attribute with namespace support that can be | |
inserted into an element. The name of the attribute is \a qName | |
and the namespace URI is \a nsURI. This function also sets | |
QDomNode::prefix() and QDomNode::localName() to appropriate values | |
(depending on \a qName). | |
If \a qName is not a valid XML name, the behavior of this function is governed by | |
QDomImplementation::InvalidDataPolicy. | |
\sa createAttribute() | |
*/ | |
QDomAttr QDomDocument::createAttributeNS(const QString& nsURI, const QString& qName) | |
{ | |
if (!impl) | |
impl = new QDomDocumentPrivate(); | |
return QDomAttr(IMPL->createAttributeNS(nsURI, qName)); | |
} | |
/*! | |
Returns a QDomNodeList that contains all the elements in the | |
document with the local name \a localName and a namespace URI of | |
\a nsURI. The order of the node list is the order they are | |
encountered in a preorder traversal of the element tree. | |
\sa elementsByTagName() QDomElement::elementsByTagNameNS() | |
*/ | |
QDomNodeList QDomDocument::elementsByTagNameNS(const QString& nsURI, const QString& localName) | |
{ | |
return QDomNodeList(new QDomNodeListPrivate(impl, nsURI, localName)); | |
} | |
/*! | |
Returns the element whose ID is equal to \a elementId. If no | |
element with the ID was found, this function returns a \link | |
QDomNode::isNull() null element\endlink. | |
Since the QDomClasses do not know which attributes are element | |
IDs, this function returns always a \link QDomNode::isNull() null | |
element\endlink. This may change in a future version. | |
*/ | |
QDomElement QDomDocument::elementById(const QString& /*elementId*/) | |
{ | |
qWarning("elementById() is not implemented and will always return a null node."); | |
return QDomElement(); | |
} | |
/*! | |
\fn QDomNode::NodeType QDomDocument::nodeType() const | |
Returns \c DocumentNode. | |
*/ | |
#undef IMPL | |
/************************************************************** | |
* | |
* Node casting functions | |
* | |
**************************************************************/ | |
/*! | |
Converts a QDomNode into a QDomAttr. If the node is not an | |
attribute, the returned object will be \link QDomNode::isNull() | |
null\endlink. | |
\sa isAttr() | |
*/ | |
QDomAttr QDomNode::toAttr() const | |
{ | |
if (impl && impl->isAttr()) | |
return QDomAttr(((QDomAttrPrivate*)impl)); | |
return QDomAttr(); | |
} | |
/*! | |
Converts a QDomNode into a QDomCDATASection. If the node is not a | |
CDATA section, the returned object will be \link | |
QDomNode::isNull() null\endlink. | |
\sa isCDATASection() | |
*/ | |
QDomCDATASection QDomNode::toCDATASection() const | |
{ | |
if (impl && impl->isCDATASection()) | |
return QDomCDATASection(((QDomCDATASectionPrivate*)impl)); | |
return QDomCDATASection(); | |
} | |
/*! | |
Converts a QDomNode into a QDomDocumentFragment. If the node is | |
not a document fragment the returned object will be \link | |
QDomNode::isNull() null\endlink. | |
\sa isDocumentFragment() | |
*/ | |
QDomDocumentFragment QDomNode::toDocumentFragment() const | |
{ | |
if (impl && impl->isDocumentFragment()) | |
return QDomDocumentFragment(((QDomDocumentFragmentPrivate*)impl)); | |
return QDomDocumentFragment(); | |
} | |
/*! | |
Converts a QDomNode into a QDomDocument. If the node is not a | |
document the returned object will be \link QDomNode::isNull() | |
null\endlink. | |
\sa isDocument() | |
*/ | |
QDomDocument QDomNode::toDocument() const | |
{ | |
if (impl && impl->isDocument()) | |
return QDomDocument(((QDomDocumentPrivate*)impl)); | |
return QDomDocument(); | |
} | |
/*! | |
Converts a QDomNode into a QDomDocumentType. If the node is not a | |
document type the returned object will be \link QDomNode::isNull() | |
null\endlink. | |
\sa isDocumentType() | |
*/ | |
QDomDocumentType QDomNode::toDocumentType() const | |
{ | |
if (impl && impl->isDocumentType()) | |
return QDomDocumentType(((QDomDocumentTypePrivate*)impl)); | |
return QDomDocumentType(); | |
} | |
/*! | |
Converts a QDomNode into a QDomElement. If the node is not an | |
element the returned object will be \link QDomNode::isNull() | |
null\endlink. | |
\sa isElement() | |
*/ | |
QDomElement QDomNode::toElement() const | |
{ | |
if (impl && impl->isElement()) | |
return QDomElement(((QDomElementPrivate*)impl)); | |
return QDomElement(); | |
} | |
/*! | |
Converts a QDomNode into a QDomEntityReference. If the node is not | |
an entity reference, the returned object will be \link | |
QDomNode::isNull() null\endlink. | |
\sa isEntityReference() | |
*/ | |
QDomEntityReference QDomNode::toEntityReference() const | |
{ | |
if (impl && impl->isEntityReference()) | |
return QDomEntityReference(((QDomEntityReferencePrivate*)impl)); | |
return QDomEntityReference(); | |
} | |
/*! | |
Converts a QDomNode into a QDomText. If the node is not a text, | |
the returned object will be \link QDomNode::isNull() null\endlink. | |
\sa isText() | |
*/ | |
QDomText QDomNode::toText() const | |
{ | |
if (impl && impl->isText()) | |
return QDomText(((QDomTextPrivate*)impl)); | |
return QDomText(); | |
} | |
/*! | |
Converts a QDomNode into a QDomEntity. If the node is not an | |
entity the returned object will be \link QDomNode::isNull() | |
null\endlink. | |
\sa isEntity() | |
*/ | |
QDomEntity QDomNode::toEntity() const | |
{ | |
if (impl && impl->isEntity()) | |
return QDomEntity(((QDomEntityPrivate*)impl)); | |
return QDomEntity(); | |
} | |
/*! | |
Converts a QDomNode into a QDomNotation. If the node is not a | |
notation the returned object will be \link QDomNode::isNull() | |
null\endlink. | |
\sa isNotation() | |
*/ | |
QDomNotation QDomNode::toNotation() const | |
{ | |
if (impl && impl->isNotation()) | |
return QDomNotation(((QDomNotationPrivate*)impl)); | |
return QDomNotation(); | |
} | |
/*! | |
Converts a QDomNode into a QDomProcessingInstruction. If the node | |
is not a processing instruction the returned object will be \link | |
QDomNode::isNull() null\endlink. | |
\sa isProcessingInstruction() | |
*/ | |
QDomProcessingInstruction QDomNode::toProcessingInstruction() const | |
{ | |
if (impl && impl->isProcessingInstruction()) | |
return QDomProcessingInstruction(((QDomProcessingInstructionPrivate*)impl)); | |
return QDomProcessingInstruction(); | |
} | |
/*! | |
Converts a QDomNode into a QDomCharacterData. If the node is not a | |
character data node the returned object will be \link | |
QDomNode::isNull() null\endlink. | |
\sa isCharacterData() | |
*/ | |
QDomCharacterData QDomNode::toCharacterData() const | |
{ | |
if (impl && impl->isCharacterData()) | |
return QDomCharacterData(((QDomCharacterDataPrivate*)impl)); | |
return QDomCharacterData(); | |
} | |
/*! | |
Converts a QDomNode into a QDomComment. If the node is not a | |
comment the returned object will be \link QDomNode::isNull() | |
null\endlink. | |
\sa isComment() | |
*/ | |
QDomComment QDomNode::toComment() const | |
{ | |
if (impl && impl->isComment()) | |
return QDomComment(((QDomCommentPrivate*)impl)); | |
return QDomComment(); | |
} | |
/************************************************************** | |
* | |
* QDomHandler | |
* | |
**************************************************************/ | |
QDomHandler::QDomHandler(QDomDocumentPrivate* adoc, bool namespaceProcessing) | |
: errorLine(0), errorColumn(0), doc(adoc), node(adoc), cdata(false), | |
nsProcessing(namespaceProcessing), locator(0) | |
{ | |
} | |
QDomHandler::~QDomHandler() | |
{ | |
} | |
bool QDomHandler::endDocument() | |
{ | |
// ### is this really necessary? (rms) | |
if (node != doc) | |
return false; | |
return true; | |
} | |
bool QDomHandler::startDTD(const QString& name, const QString& publicId, const QString& systemId) | |
{ | |
doc->doctype()->name = name; | |
doc->doctype()->publicId = publicId; | |
doc->doctype()->systemId = systemId; | |
return true; | |
} | |
bool QDomHandler::startElement(const QString& nsURI, const QString&, const QString& qName, const QXmlAttributes& atts) | |
{ | |
// tag name | |
QDomNodePrivate* n; | |
if (nsProcessing) { | |
n = doc->createElementNS(nsURI, qName); | |
} else { | |
n = doc->createElement(qName); | |
} | |
if (!n) | |
return false; | |
n->setLocation(locator->lineNumber(), locator->columnNumber()); | |
node->appendChild(n); | |
node = n; | |
// attributes | |
for (int i=0; i<atts.length(); i++) | |
{ | |
if (nsProcessing) { | |
((QDomElementPrivate*)node)->setAttributeNS(atts.uri(i), atts.qName(i), atts.value(i)); | |
} else { | |
((QDomElementPrivate*)node)->setAttribute(atts.qName(i), atts.value(i)); | |
} | |
} | |
return true; | |
} | |
bool QDomHandler::endElement(const QString&, const QString&, const QString&) | |
{ | |
if (!node || node == doc) | |
return false; | |
node = node->parent(); | |
return true; | |
} | |
bool QDomHandler::characters(const QString& ch) | |
{ | |
// No text as child of some document | |
if (node == doc) | |
return false; | |
QScopedPointer<QDomNodePrivate> n; | |
if (cdata) { | |
n.reset(doc->createCDATASection(ch)); | |
} else if (!entityName.isEmpty()) { | |
QScopedPointer<QDomEntityPrivate> e(new QDomEntityPrivate(doc, 0, entityName, | |
QString(), QString(), QString())); | |
e->value = ch; | |
doc->doctype()->appendChild(e.data()); | |
e.take(); | |
n.reset(doc->createEntityReference(entityName)); | |
} else { | |
n.reset(doc->createTextNode(ch)); | |
} | |
n->setLocation(locator->lineNumber(), locator->columnNumber()); | |
node->appendChild(n.data()); | |
n.take(); | |
return true; | |
} | |
bool QDomHandler::processingInstruction(const QString& target, const QString& data) | |
{ | |
QDomNodePrivate *n; | |
n = doc->createProcessingInstruction(target, data); | |
if (n) { | |
n->setLocation(locator->lineNumber(), locator->columnNumber()); | |
node->appendChild(n); | |
return true; | |
} | |
else | |
return false; | |
} | |
extern bool qt_xml_skipped_entity_in_content; | |
bool QDomHandler::skippedEntity(const QString& name) | |
{ | |
// we can only handle inserting entity references into content | |
if (!qt_xml_skipped_entity_in_content) | |
return true; | |
QDomNodePrivate *n = doc->createEntityReference(name); | |
n->setLocation(locator->lineNumber(), locator->columnNumber()); | |
node->appendChild(n); | |
return true; | |
} | |
bool QDomHandler::fatalError(const QXmlParseException& exception) | |
{ | |
errorMsg = exception.message(); | |
errorLine = exception.lineNumber(); | |
errorColumn = exception.columnNumber(); | |
return QXmlDefaultHandler::fatalError(exception); | |
} | |
bool QDomHandler::startCDATA() | |
{ | |
cdata = true; | |
return true; | |
} | |
bool QDomHandler::endCDATA() | |
{ | |
cdata = false; | |
return true; | |
} | |
bool QDomHandler::startEntity(const QString &name) | |
{ | |
entityName = name; | |
return true; | |
} | |
bool QDomHandler::endEntity(const QString &) | |
{ | |
entityName.clear(); | |
return true; | |
} | |
bool QDomHandler::comment(const QString& ch) | |
{ | |
QDomNodePrivate *n; | |
n = doc->createComment(ch); | |
n->setLocation(locator->lineNumber(), locator->columnNumber()); | |
node->appendChild(n); | |
return true; | |
} | |
bool QDomHandler::unparsedEntityDecl(const QString &name, const QString &publicId, const QString &systemId, const QString ¬ationName) | |
{ | |
QDomEntityPrivate* e = new QDomEntityPrivate(doc, 0, name, | |
publicId, systemId, notationName); | |
doc->doctype()->appendChild(e); | |
return true; | |
} | |
bool QDomHandler::externalEntityDecl(const QString &name, const QString &publicId, const QString &systemId) | |
{ | |
return unparsedEntityDecl(name, publicId, systemId, QString()); | |
} | |
bool QDomHandler::notationDecl(const QString & name, const QString & publicId, const QString & systemId) | |
{ | |
QDomNotationPrivate* n = new QDomNotationPrivate(doc, 0, name, publicId, systemId); | |
doc->doctype()->appendChild(n); | |
return true; | |
} | |
void QDomHandler::setDocumentLocator(QXmlLocator *locator) | |
{ | |
this->locator = locator; | |
} | |
QT_END_NAMESPACE | |
#endif // QT_NO_DOM |