include/QtCore/qxmlstream.h

0001 // Copyright (C) 2016 The Qt Company Ltd.
0002 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
0003
0004 #ifndef QXMLSTREAM_H
0005 #define QXMLSTREAM_H
0006
0007 #include <QtCore/qiodevice.h>
0008
0009 #if QT_CONFIG(xmlstream)
0010
0011 #include <QtCore/qcompare.h>
0012 #include <QtCore/qlist.h>
0013 #include <QtCore/qscopedpointer.h>
0014 #include <QtCore/qstring.h>
0015
0016 #include <memory>
0017
0018 QT_BEGIN_NAMESPACE
0019
0020 namespace QtPrivate {
0021
0022 class QXmlString {
0023     QStringPrivate m_string;
0024 public:
0025     QXmlString(QStringPrivate &&d) : m_string(std::move(d)) {}
0026     QXmlString(const QString &s) : m_string(s.data_ptr()) {}
0027     QXmlString & operator=(const QString &s) { m_string = s.data_ptr(); return *this; }
0028     QXmlString & operator=(QString &&s) { m_string.swap(s.data_ptr()); return *this; }
0029     inline constexpr QXmlString() {}
0030
0031     void swap(QXmlString &other) noexcept
0032     {
0033         m_string.swap(other.m_string);
0034     }
0035
0036     operator QStringView() const noexcept { return QStringView(m_string.data(), m_string.size); }
0037     qsizetype size() const noexcept { return m_string.size; }
0038     bool isNull() const noexcept { return m_string.isNull(); }
0039
0040 private:
0041     friend bool comparesEqual(const QXmlString &lhs, const QXmlString &rhs) noexcept
0042     {
0043         return QStringView(lhs) == QStringView(rhs);
0044     }
0045     Q_DECLARE_EQUALITY_COMPARABLE(QXmlString)
0046 };
0047
0048 }
0049 Q_DECLARE_SHARED_NS_EXT(QtPrivate, QXmlString)
0050
0051
0052 class QXmlStreamReaderPrivate;
0053 class QXmlStreamAttributes;
0054 class Q_CORE_EXPORT QXmlStreamAttribute {
0055     QtPrivate::QXmlString m_name, m_namespaceUri, m_qualifiedName, m_value;
0056     uint m_isDefault : 1;
0057     friend class QXmlStreamReaderPrivate;
0058     friend class QXmlStreamAttributes;
0059 public:
0060     QXmlStreamAttribute();
0061     QXmlStreamAttribute(const QString &qualifiedName, const QString &value);
0062     QXmlStreamAttribute(const QString &namespaceUri, const QString &name, const QString &value);
0063
0064     inline QStringView namespaceUri() const { return m_namespaceUri; }
0065     inline QStringView name() const { return m_name; }
0066     inline QStringView qualifiedName() const { return m_qualifiedName; }
0067     inline QStringView prefix() const {
0068         return QStringView(m_qualifiedName).left(qMax(0, m_qualifiedName.size() - m_name.size() - 1));
0069     }
0070     inline QStringView value() const { return m_value; }
0071     inline bool isDefault() const { return m_isDefault; }
0072 #if QT_CORE_REMOVED_SINCE(6, 8)
0073     inline bool operator==(const QXmlStreamAttribute &other) const
0074     { return comparesEqual(*this, other); }
0075     inline bool operator!=(const QXmlStreamAttribute &other) const
0076     { return !operator==(other); }
0077 #endif
0078
0079 private:
0080     friend bool comparesEqual(const QXmlStreamAttribute &lhs,
0081                               const QXmlStreamAttribute &rhs) noexcept
0082     {
0083         if (lhs.m_value != rhs.m_value)
0084             return false;
0085         if (lhs.m_namespaceUri.isNull())
0086             return lhs.m_qualifiedName == rhs.m_qualifiedName;
0087         return lhs.m_namespaceUri == rhs.m_namespaceUri
0088             && lhs.m_name == rhs.m_name;
0089     }
0090     Q_DECLARE_EQUALITY_COMPARABLE(QXmlStreamAttribute)
0091 };
0092
0093 Q_DECLARE_TYPEINFO(QXmlStreamAttribute, Q_RELOCATABLE_TYPE);
0094
0095 // We export each out-of-line method individually to prevent MSVC from
0096 // exporting the whole QList class.
0097 class QXmlStreamAttributes : public QList<QXmlStreamAttribute>
0098 {
0099 public:
0100     inline QXmlStreamAttributes() {}
0101 #if QT_CORE_REMOVED_SINCE(6, 6)
0102     Q_CORE_EXPORT QStringView value(const QString &namespaceUri, const QString &name) const;
0103     Q_CORE_EXPORT QStringView value(const QString &namespaceUri, QLatin1StringView name) const;
0104     Q_CORE_EXPORT QStringView value(QLatin1StringView namespaceUri, QLatin1StringView name) const;
0105     Q_CORE_EXPORT QStringView value(const QString &qualifiedName) const;
0106     Q_CORE_EXPORT QStringView value(QLatin1StringView qualifiedName) const;
0107 #endif
0108     Q_CORE_EXPORT QStringView value(QAnyStringView namespaceUri, QAnyStringView name) const noexcept;
0109     Q_CORE_EXPORT QStringView value(QAnyStringView qualifiedName) const noexcept;
0110
0111     Q_CORE_EXPORT void append(const QString &namespaceUri, const QString &name, const QString &value);
0112     Q_CORE_EXPORT void append(const QString &qualifiedName, const QString &value);
0113
0114     bool hasAttribute(QAnyStringView qualifiedName) const
0115     {
0116         return !value(qualifiedName).isNull();
0117     }
0118
0119     bool hasAttribute(QAnyStringView namespaceUri, QAnyStringView name) const
0120     {
0121         return !value(namespaceUri, name).isNull();
0122     }
0123
0124     using QList<QXmlStreamAttribute>::append;
0125 };
0126
0127 class Q_CORE_EXPORT QXmlStreamNamespaceDeclaration {
0128     QtPrivate::QXmlString m_prefix, m_namespaceUri;
0129
0130     friend class QXmlStreamReaderPrivate;
0131 public:
0132     QXmlStreamNamespaceDeclaration();
0133     QXmlStreamNamespaceDeclaration(const QString &prefix, const QString &namespaceUri);
0134
0135     inline QStringView prefix() const { return m_prefix; }
0136     inline QStringView namespaceUri() const { return m_namespaceUri; }
0137 #if QT_CORE_REMOVED_SINCE(6, 8)
0138     inline bool operator==(const QXmlStreamNamespaceDeclaration &other) const
0139     { return comparesEqual(*this, other); }
0140     inline bool operator!=(const QXmlStreamNamespaceDeclaration &other) const
0141     { return !operator==(other); }
0142 #endif
0143 private:
0144     friend bool comparesEqual(const QXmlStreamNamespaceDeclaration &lhs,
0145                               const QXmlStreamNamespaceDeclaration &rhs) noexcept
0146     {
0147         return lhs.m_prefix == rhs.m_prefix
0148             && lhs.m_namespaceUri == rhs.m_namespaceUri;
0149     }
0150     Q_DECLARE_EQUALITY_COMPARABLE(QXmlStreamNamespaceDeclaration)
0151 };
0152
0153 Q_DECLARE_TYPEINFO(QXmlStreamNamespaceDeclaration, Q_RELOCATABLE_TYPE);
0154 typedef QList<QXmlStreamNamespaceDeclaration> QXmlStreamNamespaceDeclarations;
0155
0156 class Q_CORE_EXPORT QXmlStreamNotationDeclaration {
0157     QtPrivate::QXmlString m_name, m_systemId, m_publicId;
0158
0159     friend class QXmlStreamReaderPrivate;
0160 public:
0161     QXmlStreamNotationDeclaration();
0162
0163     inline QStringView name() const { return m_name; }
0164     inline QStringView systemId() const { return m_systemId; }
0165     inline QStringView publicId() const { return m_publicId; }
0166 #if QT_CORE_REMOVED_SINCE(6, 8)
0167     inline bool operator==(const QXmlStreamNotationDeclaration &other) const
0168     { return comparesEqual(*this, other); }
0169     inline bool operator!=(const QXmlStreamNotationDeclaration &other) const
0170     { return !operator==(other); }
0171 #endif
0172 private:
0173     friend bool comparesEqual(const QXmlStreamNotationDeclaration &lhs,
0174                               const QXmlStreamNotationDeclaration &rhs) noexcept
0175     {
0176         return lhs.m_name == rhs.m_name && lhs.m_systemId == rhs.m_systemId
0177                 && lhs.m_publicId == rhs.m_publicId;
0178     }
0179     Q_DECLARE_EQUALITY_COMPARABLE(QXmlStreamNotationDeclaration)
0180 };
0181
0182 Q_DECLARE_TYPEINFO(QXmlStreamNotationDeclaration, Q_RELOCATABLE_TYPE);
0183 typedef QList<QXmlStreamNotationDeclaration> QXmlStreamNotationDeclarations;
0184
0185 class Q_CORE_EXPORT QXmlStreamEntityDeclaration {
0186     QtPrivate::QXmlString m_name, m_notationName, m_systemId, m_publicId, m_value;
0187
0188     friend class QXmlStreamReaderPrivate;
0189 public:
0190     QXmlStreamEntityDeclaration();
0191
0192     inline QStringView name() const { return m_name; }
0193     inline QStringView notationName() const { return m_notationName; }
0194     inline QStringView systemId() const { return m_systemId; }
0195     inline QStringView publicId() const { return m_publicId; }
0196     inline QStringView value() const { return m_value; }
0197 #if QT_CORE_REMOVED_SINCE(6, 8)
0198     inline bool operator==(const QXmlStreamEntityDeclaration &other) const
0199     { return comparesEqual(*this, other); }
0200     inline bool operator!=(const QXmlStreamEntityDeclaration &other) const
0201     { return !operator==(other); }
0202 #endif
0203
0204 private:
0205     friend bool comparesEqual(const QXmlStreamEntityDeclaration &lhs,
0206                               const QXmlStreamEntityDeclaration &rhs) noexcept
0207     {
0208         return lhs.m_name == rhs.m_name
0209             && lhs.m_notationName == rhs.m_notationName
0210             && lhs.m_systemId == rhs.m_systemId
0211             && lhs.m_publicId == rhs.m_publicId
0212             && lhs.m_value == rhs.m_value;
0213     }
0214     Q_DECLARE_EQUALITY_COMPARABLE(QXmlStreamEntityDeclaration)
0215 };
0216
0217 Q_DECLARE_TYPEINFO(QXmlStreamEntityDeclaration, Q_RELOCATABLE_TYPE);
0218 typedef QList<QXmlStreamEntityDeclaration> QXmlStreamEntityDeclarations;
0219
0220 class Q_CORE_EXPORT QXmlStreamEntityResolver
0221 {
0222     Q_DISABLE_COPY_MOVE(QXmlStreamEntityResolver)
0223 public:
0224     QXmlStreamEntityResolver() = default;
0225     virtual ~QXmlStreamEntityResolver();
0226     virtual QString resolveEntity(const QString& publicId, const QString& systemId);
0227     virtual QString resolveUndeclaredEntity(const QString &name);
0228 };
0229
0230 #if QT_CONFIG(xmlstreamreader)
0231 class Q_CORE_EXPORT QXmlStreamReader
0232 {
0233     QDOC_PROPERTY(bool namespaceProcessing READ namespaceProcessing WRITE setNamespaceProcessing)
0234 public:
0235     enum TokenType {
0236         NoToken = 0,
0237         Invalid,
0238         StartDocument,
0239         EndDocument,
0240         StartElement,
0241         EndElement,
0242         Characters,
0243         Comment,
0244         DTD,
0245         EntityReference,
0246         ProcessingInstruction
0247     };
0248
0249
0250     QXmlStreamReader();
0251     explicit QXmlStreamReader(QIODevice *device);
0252 #if QT_CORE_REMOVED_SINCE(6, 5)
0253     explicit QXmlStreamReader(const QByteArray &data);
0254     explicit QXmlStreamReader(const QString &data);
0255     explicit QXmlStreamReader(const char * data);
0256 #endif // QT_CORE_REMOVED_SINCE(6, 5)
0257     Q_WEAK_OVERLOAD
0258     explicit QXmlStreamReader(const QByteArray &data)
0259         : QXmlStreamReader(data, PrivateConstructorTag{}) { }
0260     explicit QXmlStreamReader(QAnyStringView data);
0261     ~QXmlStreamReader();
0262
0263     void setDevice(QIODevice *device);
0264     QIODevice *device() const;
0265 #if QT_CORE_REMOVED_SINCE(6, 5)
0266     void addData(const QByteArray &data);
0267     void addData(const QString &data);
0268     void addData(const char *data);
0269 #endif // QT_CORE_REMOVED_SINCE(6, 5)
0270     Q_WEAK_OVERLOAD
0271     void addData(const QByteArray &data) { addDataImpl(data); }
0272     void addData(QAnyStringView data);
0273     void clear();
0274
0275
0276     bool atEnd() const;
0277     TokenType readNext();
0278
0279     bool readNextStartElement();
0280     void skipCurrentElement();
0281
0282     TokenType tokenType() const;
0283     QString tokenString() const;
0284
0285     void setNamespaceProcessing(bool);
0286     bool namespaceProcessing() const;
0287
0288     inline bool isStartDocument() const { return tokenType() == StartDocument; }
0289     inline bool isEndDocument() const { return tokenType() == EndDocument; }
0290     inline bool isStartElement() const { return tokenType() == StartElement; }
0291     inline bool isEndElement() const { return tokenType() == EndElement; }
0292     inline bool isCharacters() const { return tokenType() == Characters; }
0293     bool isWhitespace() const;
0294     bool isCDATA() const;
0295     inline bool isComment() const { return tokenType() == Comment; }
0296     inline bool isDTD() const { return tokenType() == DTD; }
0297     inline bool isEntityReference() const { return tokenType() == EntityReference; }
0298     inline bool isProcessingInstruction() const { return tokenType() == ProcessingInstruction; }
0299
0300     bool isStandaloneDocument() const;
0301     bool hasStandaloneDeclaration() const;
0302     QStringView documentVersion() const;
0303     QStringView documentEncoding() const;
0304
0305     qint64 lineNumber() const;
0306     qint64 columnNumber() const;
0307     qint64 characterOffset() const;
0308
0309     QXmlStreamAttributes attributes() const;
0310
0311     enum ReadElementTextBehaviour {
0312         ErrorOnUnexpectedElement,
0313         IncludeChildElements,
0314         SkipChildElements
0315     };
0316     QString readElementText(ReadElementTextBehaviour behaviour = ErrorOnUnexpectedElement);
0317
0318     QStringView name() const;
0319     QStringView namespaceUri() const;
0320     QStringView qualifiedName() const;
0321     QStringView prefix() const;
0322
0323     QStringView processingInstructionTarget() const;
0324     QStringView processingInstructionData() const;
0325
0326     QStringView text() const;
0327
0328     QXmlStreamNamespaceDeclarations namespaceDeclarations() const;
0329     void addExtraNamespaceDeclaration(const QXmlStreamNamespaceDeclaration &extraNamespaceDeclaraction);
0330     void addExtraNamespaceDeclarations(const QXmlStreamNamespaceDeclarations &extraNamespaceDeclaractions);
0331     QXmlStreamNotationDeclarations notationDeclarations() const;
0332     QXmlStreamEntityDeclarations entityDeclarations() const;
0333     QStringView dtdName() const;
0334     QStringView dtdPublicId() const;
0335     QStringView dtdSystemId() const;
0336
0337     int entityExpansionLimit() const;
0338     void setEntityExpansionLimit(int limit);
0339
0340     enum Error {
0341         NoError,
0342         UnexpectedElementError,
0343         CustomError,
0344         NotWellFormedError,
0345         PrematureEndOfDocumentError
0346     };
0347     void raiseError(const QString& message = QString());
0348     QString errorString() const;
0349     Error error() const;
0350
0351     inline bool hasError() const
0352     {
0353         return error() != NoError;
0354     }
0355
0356     void setEntityResolver(QXmlStreamEntityResolver *resolver);
0357     QXmlStreamEntityResolver *entityResolver() const;
0358
0359 private:
0360     struct PrivateConstructorTag { };
0361     QXmlStreamReader(const QByteArray &data, PrivateConstructorTag);
0362     void addDataImpl(const QByteArray &data);
0363
0364     Q_DISABLE_COPY(QXmlStreamReader)
0365     Q_DECLARE_PRIVATE(QXmlStreamReader)
0366     std::unique_ptr<QXmlStreamReaderPrivate> d_ptr;
0367
0368 };
0369 #endif // feature xmlstreamreader
0370
0371 #if QT_CONFIG(xmlstreamwriter)
0372
0373 class QXmlStreamWriterPrivate;
0374
0375 class Q_CORE_EXPORT QXmlStreamWriter
0376 {
0377     QDOC_PROPERTY(bool autoFormatting READ autoFormatting WRITE setAutoFormatting)
0378     QDOC_PROPERTY(int autoFormattingIndent READ autoFormattingIndent WRITE setAutoFormattingIndent)
0379 public:
0380     QXmlStreamWriter();
0381     explicit QXmlStreamWriter(QIODevice *device);
0382     explicit QXmlStreamWriter(QByteArray *array);
0383     explicit QXmlStreamWriter(QString *string);
0384     ~QXmlStreamWriter();
0385
0386     void setDevice(QIODevice *device);
0387     QIODevice *device() const;
0388
0389     void setAutoFormatting(bool);
0390     bool autoFormatting() const;
0391
0392     void setAutoFormattingIndent(int spacesOrTabs);
0393     int autoFormattingIndent() const;
0394
0395 #if QT_CORE_REMOVED_SINCE(6,5)
0396     void writeAttribute(const QString &qualifiedName, const QString &value);
0397     void writeAttribute(const QString &namespaceUri, const QString &name, const QString &value);
0398 #endif
0399     void writeAttribute(QAnyStringView qualifiedName, QAnyStringView value);
0400     void writeAttribute(QAnyStringView namespaceUri, QAnyStringView name, QAnyStringView value);
0401
0402     void writeAttribute(const QXmlStreamAttribute& attribute);
0403     void writeAttributes(const QXmlStreamAttributes& attributes);
0404
0405 #if QT_CORE_REMOVED_SINCE(6,5)
0406     void writeCDATA(const QString &text);
0407     void writeCharacters(const QString &text);
0408     void writeComment(const QString &text);
0409
0410     void writeDTD(const QString &dtd);
0411
0412     void writeEmptyElement(const QString &qualifiedName);
0413     void writeEmptyElement(const QString &namespaceUri, const QString &name);
0414
0415     void writeTextElement(const QString &qualifiedName, const QString &text);
0416     void writeTextElement(const QString &namespaceUri, const QString &name, const QString &text);
0417 #endif
0418     void writeCDATA(QAnyStringView text);
0419     void writeCharacters(QAnyStringView text);
0420     void writeComment(QAnyStringView text);
0421
0422     void writeDTD(QAnyStringView dtd);
0423
0424     void writeEmptyElement(QAnyStringView qualifiedName);
0425     void writeEmptyElement(QAnyStringView namespaceUri, QAnyStringView name);
0426
0427     void writeTextElement(QAnyStringView qualifiedName, QAnyStringView text);
0428     void writeTextElement(QAnyStringView namespaceUri, QAnyStringView name, QAnyStringView text);
0429
0430
0431     void writeEndDocument();
0432     void writeEndElement();
0433
0434 #if QT_CORE_REMOVED_SINCE(6,5)
0435     void writeEntityReference(const QString &name);
0436     void writeNamespace(const QString &namespaceUri, const QString &prefix);
0437     void writeDefaultNamespace(const QString &namespaceUri);
0438     void writeProcessingInstruction(const QString &target, const QString &data);
0439 #endif
0440     void writeEntityReference(QAnyStringView name);
0441     void writeNamespace(QAnyStringView namespaceUri, QAnyStringView prefix = {});
0442     void writeDefaultNamespace(QAnyStringView namespaceUri);
0443     void writeProcessingInstruction(QAnyStringView target, QAnyStringView data = {});
0444
0445     void writeStartDocument();
0446 #if QT_CORE_REMOVED_SINCE(6,5)
0447     void writeStartDocument(const QString &version);
0448     void writeStartDocument(const QString &version, bool standalone);
0449     void writeStartElement(const QString &qualifiedName);
0450     void writeStartElement(const QString &namespaceUri, const QString &name);
0451 #endif
0452     void writeStartDocument(QAnyStringView version);
0453     void writeStartDocument(QAnyStringView version, bool standalone);
0454     void writeStartElement(QAnyStringView qualifiedName);
0455     void writeStartElement(QAnyStringView namespaceUri, QAnyStringView name);
0456
0457 #if QT_CONFIG(xmlstreamreader)
0458     void writeCurrentToken(const QXmlStreamReader &reader);
0459 #endif
0460
0461     bool hasError() const;
0462
0463 private:
0464     Q_DISABLE_COPY(QXmlStreamWriter)
0465     Q_DECLARE_PRIVATE(QXmlStreamWriter)
0466     std::unique_ptr<QXmlStreamWriterPrivate> d_ptr;
0467 };
0468 #endif // feature xmlstreamwriter
0469
0470 QT_END_NAMESPACE
0471
0472 #endif // feature xmlstream
0473
0474 #endif // QXMLSTREAM_H