qxmlstream.h - mozsearch

++ // Copyright (C) 2016 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

++ // Qt-Security score:critical reason:data-parser

++

++ #ifndef QXMLSTREAM_H

++ #define QXMLSTREAM_H

++

++ #include <QtCore/qiodevice.h>

++

++ #if QT_CONFIG(xmlstream)

++

++ #include <QtCore/qcompare.h>

++ #include <QtCore/qlist.h>

++ #include <QtCore/qscopedpointer.h>

++ #include <QtCore/qstring.h>

++

++ #include <memory>

++

++ QT_BEGIN_NAMESPACE

++

++ namespace QtPrivate {

++

++ class QXmlString {

++     QStringPrivate m_string;

++ public:

++     QXmlString(QStringPrivate &&d) : m_string(std::move(d)) {}

++     QXmlString(const QString &s) : m_string(s.data_ptr()) {}

++     QXmlString & operator=(const QString &s) { m_string = s.data_ptr(); return *this; }

++     QXmlString & operator=(QString &&s) { m_string.swap(s.data_ptr()); return *this; }

++     inline constexpr QXmlString() {}

++

++     void swap(QXmlString &other) noexcept

++     {

++         m_string.swap(other.m_string);

++     }

++

++     operator QStringView() const noexcept { return QStringView(m_string.data(), m_string.size); }

++     qsizetype size() const noexcept { return m_string.size; }

++     bool isNull() const noexcept { return m_string.isNull(); }

++

++ private:

++     friend bool comparesEqual(const QXmlString &lhs, const QXmlString &rhs) noexcept

++     {

++         return QStringView(lhs) == QStringView(rhs);

++     }

++     Q_DECLARE_EQUALITY_COMPARABLE(QXmlString)

++ };

++

++ }

++ Q_DECLARE_SHARED_NS_EXT(QtPrivate, QXmlString)

++

++

++ class QXmlStreamReaderPrivate;

++ class QXmlStreamAttributes;

++ class Q_CORE_EXPORT QXmlStreamAttribute {

++     QtPrivate::QXmlString m_name, m_namespaceUri, m_qualifiedName, m_value;

++     uint m_isDefault : 1;

++     friend class QXmlStreamReaderPrivate;

++     friend class QXmlStreamAttributes;

++ public:

++     QXmlStreamAttribute();

++     QXmlStreamAttribute(const QString &qualifiedName, const QString &value);

++     QXmlStreamAttribute(const QString &namespaceUri, const QString &name, const QString &value);

++

++     inline QStringView namespaceUri() const { return m_namespaceUri; }

++     inline QStringView name() const { return m_name; }

++     inline QStringView qualifiedName() const { return m_qualifiedName; }

++     inline QStringView prefix() const {

++         return QStringView(m_qualifiedName).left(qMax(0, m_qualifiedName.size() - m_name.size() - 1));

++     }

++     inline QStringView value() const { return m_value; }

++     inline bool isDefault() const { return m_isDefault; }

++ #if QT_CORE_REMOVED_SINCE(6, 8)

++     inline bool operator==(const QXmlStreamAttribute &other) const

++     { return comparesEqual(*this, other); }

++     inline bool operator!=(const QXmlStreamAttribute &other) const

++     { return !operator==(other); }

++ #endif

++

++ private:

++     friend bool comparesEqual(const QXmlStreamAttribute &lhs,

++                               const QXmlStreamAttribute &rhs) noexcept

++     {

++         if (lhs.m_value != rhs.m_value)

++             return false;

++         if (lhs.m_namespaceUri.isNull())

++             return lhs.m_qualifiedName == rhs.m_qualifiedName;

++         return lhs.m_namespaceUri == rhs.m_namespaceUri

++             && lhs.m_name == rhs.m_name;

++     }

++     Q_DECLARE_EQUALITY_COMPARABLE(QXmlStreamAttribute)

++ };

++

++ Q_DECLARE_TYPEINFO(QXmlStreamAttribute, Q_RELOCATABLE_TYPE);

++

++ // We export each out-of-line method individually to prevent MSVC from

++ // exporting the whole QList class.

++ class QXmlStreamAttributes : public QList<QXmlStreamAttribute>

++ {

++ public:

++     inline QXmlStreamAttributes() {}

++ #if QT_CORE_REMOVED_SINCE(6, 6)

++     Q_CORE_EXPORT QStringView value(const QString &namespaceUri, const QString &name) const;

++     Q_CORE_EXPORT QStringView value(const QString &namespaceUri, QLatin1StringView name) const;

++     Q_CORE_EXPORT QStringView value(QLatin1StringView namespaceUri, QLatin1StringView name) const;

++     Q_CORE_EXPORT QStringView value(const QString &qualifiedName) const;

++     Q_CORE_EXPORT QStringView value(QLatin1StringView qualifiedName) const;

++ #endif

++     Q_CORE_EXPORT QStringView value(QAnyStringView namespaceUri, QAnyStringView name) const noexcept;

++     Q_CORE_EXPORT QStringView value(QAnyStringView qualifiedName) const noexcept;

++

++     Q_CORE_EXPORT void append(const QString &namespaceUri, const QString &name, const QString &value);

++     Q_CORE_EXPORT void append(const QString &qualifiedName, const QString &value);

++

++     bool hasAttribute(QAnyStringView qualifiedName) const

++     {

++         return !value(qualifiedName).isNull();

++     }

++

++     bool hasAttribute(QAnyStringView namespaceUri, QAnyStringView name) const

++     {

++         return !value(namespaceUri, name).isNull();

++     }

++

++     using QList<QXmlStreamAttribute>::append;

++ };

++

++ class Q_CORE_EXPORT QXmlStreamNamespaceDeclaration {

++     QtPrivate::QXmlString m_prefix, m_namespaceUri;

++

++     friend class QXmlStreamReaderPrivate;

++ public:

++     QXmlStreamNamespaceDeclaration();

++     QXmlStreamNamespaceDeclaration(const QString &prefix, const QString &namespaceUri);

++

++     inline QStringView prefix() const { return m_prefix; }

++     inline QStringView namespaceUri() const { return m_namespaceUri; }

++ #if QT_CORE_REMOVED_SINCE(6, 8)

++     inline bool operator==(const QXmlStreamNamespaceDeclaration &other) const

++     { return comparesEqual(*this, other); }

++     inline bool operator!=(const QXmlStreamNamespaceDeclaration &other) const

++     { return !operator==(other); }

++ #endif

++ private:

++     friend bool comparesEqual(const QXmlStreamNamespaceDeclaration &lhs,

++                               const QXmlStreamNamespaceDeclaration &rhs) noexcept

++     {

++         return lhs.m_prefix == rhs.m_prefix

++             && lhs.m_namespaceUri == rhs.m_namespaceUri;

++     }

++     Q_DECLARE_EQUALITY_COMPARABLE(QXmlStreamNamespaceDeclaration)

++ };

++

++ Q_DECLARE_TYPEINFO(QXmlStreamNamespaceDeclaration, Q_RELOCATABLE_TYPE);

++ typedef QList<QXmlStreamNamespaceDeclaration> QXmlStreamNamespaceDeclarations;

++

++ class Q_CORE_EXPORT QXmlStreamNotationDeclaration {

++     QtPrivate::QXmlString m_name, m_systemId, m_publicId;

++

++     friend class QXmlStreamReaderPrivate;

++ public:

++     QXmlStreamNotationDeclaration();

++

++     inline QStringView name() const { return m_name; }

++     inline QStringView systemId() const { return m_systemId; }

++     inline QStringView publicId() const { return m_publicId; }

++ #if QT_CORE_REMOVED_SINCE(6, 8)

++     inline bool operator==(const QXmlStreamNotationDeclaration &other) const

++     { return comparesEqual(*this, other); }

++     inline bool operator!=(const QXmlStreamNotationDeclaration &other) const

++     { return !operator==(other); }

++ #endif

++ private:

++     friend bool comparesEqual(const QXmlStreamNotationDeclaration &lhs,

++                               const QXmlStreamNotationDeclaration &rhs) noexcept

++     {

++         return lhs.m_name == rhs.m_name && lhs.m_systemId == rhs.m_systemId

++                 && lhs.m_publicId == rhs.m_publicId;

++     }

++     Q_DECLARE_EQUALITY_COMPARABLE(QXmlStreamNotationDeclaration)

++ };

++

++ Q_DECLARE_TYPEINFO(QXmlStreamNotationDeclaration, Q_RELOCATABLE_TYPE);

++ typedef QList<QXmlStreamNotationDeclaration> QXmlStreamNotationDeclarations;

++

++ class Q_CORE_EXPORT QXmlStreamEntityDeclaration {

++     QtPrivate::QXmlString m_name, m_notationName, m_systemId, m_publicId, m_value;

++

++     friend class QXmlStreamReaderPrivate;

++ public:

++     QXmlStreamEntityDeclaration();

++

++     inline QStringView name() const { return m_name; }

++     inline QStringView notationName() const { return m_notationName; }

++     inline QStringView systemId() const { return m_systemId; }

++     inline QStringView publicId() const { return m_publicId; }

++     inline QStringView value() const { return m_value; }

++ #if QT_CORE_REMOVED_SINCE(6, 8)

++     inline bool operator==(const QXmlStreamEntityDeclaration &other) const

++     { return comparesEqual(*this, other); }

++     inline bool operator!=(const QXmlStreamEntityDeclaration &other) const

++     { return !operator==(other); }

++ #endif

++

++ private:

++     friend bool comparesEqual(const QXmlStreamEntityDeclaration &lhs,

++                               const QXmlStreamEntityDeclaration &rhs) noexcept

++     {

++         return lhs.m_name == rhs.m_name

++             && lhs.m_notationName == rhs.m_notationName

++             && lhs.m_systemId == rhs.m_systemId

++             && lhs.m_publicId == rhs.m_publicId

++             && lhs.m_value == rhs.m_value;

++     }

++     Q_DECLARE_EQUALITY_COMPARABLE(QXmlStreamEntityDeclaration)

++ };

++

++ Q_DECLARE_TYPEINFO(QXmlStreamEntityDeclaration, Q_RELOCATABLE_TYPE);

++ typedef QList<QXmlStreamEntityDeclaration> QXmlStreamEntityDeclarations;

++

++ class Q_CORE_EXPORT QXmlStreamEntityResolver

++ {

++     Q_DISABLE_COPY_MOVE(QXmlStreamEntityResolver)

++ public:

++     QXmlStreamEntityResolver() = default;

++     virtual ~QXmlStreamEntityResolver();

++     QT_WARNING_PUSH

++     #if defined(__has_warning)

++     #  if __has_warning("-Wunnecessary-virtual-specifier")

++     QT_WARNING_DISABLE_CLANG("-Wunnecessary-virtual-specifier")

++     #  endif

++     #endif

++     // This isn't called anywhere, and marked as \internal. It merely reserves a slot in

++     // the vtable. In particular, we reserve the right to change the signature before

++     // taking the API into use, so mark final to prevent users from overriding before that:

++     virtual QString resolveEntity(const QString& publicId, const QString& systemId) final;

++     QT_WARNING_POP

++     virtual QString resolveUndeclaredEntity(const QString &name);

++ };

++

++ #if QT_CONFIG(xmlstreamreader)

++ class Q_CORE_EXPORT QXmlStreamReader

++ {

++     QDOC_PROPERTY(bool namespaceProcessing READ namespaceProcessing WRITE setNamespaceProcessing)

++ public:

++     enum TokenType {

++         NoToken = 0,

++         Invalid,

++         StartDocument,

++         EndDocument,

++         StartElement,

++         EndElement,

++         Characters,

++         Comment,

++         DTD,

++         EntityReference,

++         ProcessingInstruction

++     };

++

++

++     QXmlStreamReader();

++     explicit QXmlStreamReader(QIODevice *device);

++ #if QT_CORE_REMOVED_SINCE(6, 5)

++     explicit QXmlStreamReader(const QByteArray &data);

++     explicit QXmlStreamReader(const QString &data);

++     explicit QXmlStreamReader(const char * data);

++ #endif // QT_CORE_REMOVED_SINCE(6, 5)

++     Q_WEAK_OVERLOAD

++     explicit QXmlStreamReader(const QByteArray &data)

++         : QXmlStreamReader(data, PrivateConstructorTag{}) { }

++     explicit QXmlStreamReader(QAnyStringView data);

++     ~QXmlStreamReader();

++

++     void setDevice(QIODevice *device);

++     QIODevice *device() const;

++ #if QT_CORE_REMOVED_SINCE(6, 5)

++     void addData(const QByteArray &data);

++     void addData(const QString &data);

++     void addData(const char *data);

++ #endif // QT_CORE_REMOVED_SINCE(6, 5)

++     Q_WEAK_OVERLOAD

++     void addData(const QByteArray &data) { addDataImpl(data); }

++     void addData(QAnyStringView data);

++     void clear();

++

++

++     bool atEnd() const;

++     TokenType readNext();

++

++     bool readNextStartElement();

++     void skipCurrentElement();

++     QString readRawInnerData();

++

++     TokenType tokenType() const;

++     QString tokenString() const;

++

++     void setNamespaceProcessing(bool);

++     bool namespaceProcessing() const;

++

++     inline bool isStartDocument() const { return tokenType() == StartDocument; }

++     inline bool isEndDocument() const { return tokenType() == EndDocument; }

++     inline bool isStartElement() const { return tokenType() == StartElement; }

++     inline bool isEndElement() const { return tokenType() == EndElement; }

++     inline bool isCharacters() const { return tokenType() == Characters; }

++     bool isWhitespace() const;

++     bool isCDATA() const;

++     inline bool isComment() const { return tokenType() == Comment; }

++     inline bool isDTD() const { return tokenType() == DTD; }

++     inline bool isEntityReference() const { return tokenType() == EntityReference; }

++     inline bool isProcessingInstruction() const { return tokenType() == ProcessingInstruction; }

++

++     bool isStandaloneDocument() const;

++     bool hasStandaloneDeclaration() const;

++     QStringView documentVersion() const;

++     QStringView documentEncoding() const;

++

++     qint64 lineNumber() const;

++     qint64 columnNumber() const;

++     qint64 characterOffset() const;

++

++     QXmlStreamAttributes attributes() const;

++

++     enum ReadElementTextBehaviour {

++         ErrorOnUnexpectedElement,

++         IncludeChildElements,

++         SkipChildElements

++     };

++     QString readElementText(ReadElementTextBehaviour behaviour = ErrorOnUnexpectedElement);

++

++     QStringView name() const;

++     QStringView namespaceUri() const;

++     QStringView qualifiedName() const;

++     QStringView prefix() const;

++

++     QStringView processingInstructionTarget() const;

++     QStringView processingInstructionData() const;

++

++     QStringView text() const;

++

++     QXmlStreamNamespaceDeclarations namespaceDeclarations() const;

++     void addExtraNamespaceDeclaration(const QXmlStreamNamespaceDeclaration &extraNamespaceDeclaraction);

++     void addExtraNamespaceDeclarations(const QXmlStreamNamespaceDeclarations &extraNamespaceDeclaractions);

++     QXmlStreamNotationDeclarations notationDeclarations() const;

++     QXmlStreamEntityDeclarations entityDeclarations() const;

++     QStringView dtdName() const;

++     QStringView dtdPublicId() const;

++     QStringView dtdSystemId() const;

++

++     int entityExpansionLimit() const;

++     void setEntityExpansionLimit(int limit);

++

++     enum Error {

++         NoError,

++         UnexpectedElementError,

++         CustomError,

++         NotWellFormedError,

++         PrematureEndOfDocumentError

++     };

++     void raiseError(const QString& message = QString());

++     QString errorString() const;

++     Error error() const;

++

++     inline bool hasError() const

++     {

++         return error() != NoError;

++     }

++

++     void setEntityResolver(QXmlStreamEntityResolver *resolver);

++     QXmlStreamEntityResolver *entityResolver() const;

++

++ private:

++     struct PrivateConstructorTag { };

++     QXmlStreamReader(const QByteArray &data, PrivateConstructorTag);

++     void addDataImpl(const QByteArray &data);

++

++     Q_DISABLE_COPY(QXmlStreamReader)

++     Q_DECLARE_PRIVATE(QXmlStreamReader)

++     std::unique_ptr<QXmlStreamReaderPrivate> d_ptr;

++

++ };

++ #endif // feature xmlstreamreader

++

++ #if QT_CONFIG(xmlstreamwriter)

++

++ class QXmlStreamWriterPrivate;

++

++ class Q_CORE_EXPORT QXmlStreamWriter

++ {

++     QDOC_PROPERTY(bool autoFormatting READ autoFormatting WRITE setAutoFormatting)

++     QDOC_PROPERTY(int autoFormattingIndent READ autoFormattingIndent WRITE setAutoFormattingIndent)

++     QDOC_PROPERTY(bool stopWritingOnError READ stopWritingOnError WRITE setStopWritingOnError)

++ public:

++     QXmlStreamWriter();

++     explicit QXmlStreamWriter(QIODevice *device);

++     explicit QXmlStreamWriter(QByteArray *array);

++     explicit QXmlStreamWriter(QString *string);

++     ~QXmlStreamWriter();

++

++     void setDevice(QIODevice *device);

++     QIODevice *device() const;

++

++     void setAutoFormatting(bool);

++     bool autoFormatting() const;

++

++     void setAutoFormattingIndent(int spacesOrTabs);

++     int autoFormattingIndent() const;

++

++     void setStopWritingOnError(bool stop);

++     bool stopWritingOnError() const;

++

++ #if QT_CORE_REMOVED_SINCE(6,5)

++     void writeAttribute(const QString &qualifiedName, const QString &value);

++     void writeAttribute(const QString &namespaceUri, const QString &name, const QString &value);

++ #endif

++     void writeAttribute(QAnyStringView qualifiedName, QAnyStringView value);

++     void writeAttribute(QAnyStringView namespaceUri, QAnyStringView name, QAnyStringView value);

++

++     void writeAttribute(const QXmlStreamAttribute& attribute);

++     void writeAttributes(const QXmlStreamAttributes& attributes);

++

++ #if QT_CORE_REMOVED_SINCE(6,5)

++     void writeCDATA(const QString &text);

++     void writeCharacters(const QString &text);

++     void writeComment(const QString &text);

++

++     void writeDTD(const QString &dtd);

++

++     void writeEmptyElement(const QString &qualifiedName);

++     void writeEmptyElement(const QString &namespaceUri, const QString &name);

++

++     void writeTextElement(const QString &qualifiedName, const QString &text);

++     void writeTextElement(const QString &namespaceUri, const QString &name, const QString &text);

++ #endif

++     void writeCDATA(QAnyStringView text);

++     void writeCharacters(QAnyStringView text);

++     void writeComment(QAnyStringView text);

++

++     void writeDTD(QAnyStringView dtd);

++

++     void writeEmptyElement(QAnyStringView qualifiedName);

++     void writeEmptyElement(QAnyStringView namespaceUri, QAnyStringView name);

++

++     void writeTextElement(QAnyStringView qualifiedName, QAnyStringView text);

++     void writeTextElement(QAnyStringView namespaceUri, QAnyStringView name, QAnyStringView text);

++

++

++     void writeEndDocument();

++     void writeEndElement();

++

++ #if QT_CORE_REMOVED_SINCE(6,5)

++     void writeEntityReference(const QString &name);

++     void writeNamespace(const QString &namespaceUri, const QString &prefix);

++     void writeDefaultNamespace(const QString &namespaceUri);

++     void writeProcessingInstruction(const QString &target, const QString &data);

++ #endif

++     void writeEntityReference(QAnyStringView name);

++     void writeNamespace(QAnyStringView namespaceUri, QAnyStringView prefix = {});

++     void writeDefaultNamespace(QAnyStringView namespaceUri);

++     void writeProcessingInstruction(QAnyStringView target, QAnyStringView data = {});

++

++     void writeStartDocument();

++ #if QT_CORE_REMOVED_SINCE(6,5)

++     void writeStartDocument(const QString &version);

++     void writeStartDocument(const QString &version, bool standalone);

++     void writeStartElement(const QString &qualifiedName);

++     void writeStartElement(const QString &namespaceUri, const QString &name);

++ #endif

++     void writeStartDocument(QAnyStringView version);

++     void writeStartDocument(QAnyStringView version, bool standalone);

++     void writeStartElement(QAnyStringView qualifiedName);

++     void writeStartElement(QAnyStringView namespaceUri, QAnyStringView name);

++

++ #if QT_CONFIG(xmlstreamreader)

++     void writeCurrentToken(const QXmlStreamReader &reader);

++ #endif

++

++     enum class Error {

++         None,

++         IO,

++         Encoding,

++         InvalidCharacter,

++         Custom,

++     };

++

++     void raiseError(QAnyStringView message);

++     QString errorString() const;

++     Error error() const;

++     bool hasError() const;

++

++ private:

++     Q_DISABLE_COPY(QXmlStreamWriter)

++     Q_DECLARE_PRIVATE(QXmlStreamWriter)

++     std::unique_ptr<QXmlStreamWriterPrivate> d_ptr;

++ };

++ #endif // feature xmlstreamwriter

++

++ QT_END_NAMESPACE

++

++ #endif // feature xmlstream

++

++ #endif // QXMLSTREAM_H

Revision control