mirror of
https://github.com/baldurk/renderdoc.git
synced 2026-05-27 04:11:05 +00:00
baldurk
768e812e45
* On windows it's strongly desired to be able to compile straight out of a clean checkout or source download. This means anyone can download the source and investigate something quickly, without having to worry about the hassle of figuring out how the project downloads 3rd party dependencies, fetching them, getting them registered in the right place. * This can't be put in a submodule as git submodules don't get downloaded by default so people new to git will get confusing compilation messages, and someone downloading the source from github directly without cloning via git won't get submodules included. * It does add some extra size to a fresh download/checkout which is unfortunate, but absolutely worth the cost. Shallow checkouts still aren't unfeasibly large, and it's only a one-off cost at clone time.
541 lines
20 KiB
C++
541 lines
20 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2016 The Qt Company Ltd.
|
|
** Contact: https://www.qt.io/licensing/
|
|
**
|
|
** This file is part of the QtCore module of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:LGPL$
|
|
** Commercial License Usage
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
** accordance with the commercial license agreement provided with the
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
** a written agreement between you and The Qt Company. For licensing terms
|
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at https://www.qt.io/contact-us.
|
|
**
|
|
** GNU Lesser General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU Lesser
|
|
** General Public License version 3 as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.LGPL3 included in the
|
|
** packaging of this file. Please review the following information to
|
|
** ensure the GNU Lesser General Public License version 3 requirements
|
|
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 2.0 or (at your option) the GNU General
|
|
** Public license version 3 or any later version approved by the KDE Free
|
|
** Qt Foundation. The licenses are as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
|
|
** included in the packaging of this file. Please review the following
|
|
** information to ensure the GNU General Public License requirements will
|
|
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
|
|
** https://www.gnu.org/licenses/gpl-3.0.html.
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
#ifndef QXMLSTREAM_H
|
|
#define QXMLSTREAM_H
|
|
|
|
#include <QtCore/qiodevice.h>
|
|
|
|
#ifndef QT_NO_XMLSTREAM
|
|
|
|
#include <QtCore/qstring.h>
|
|
#include <QtCore/qvector.h>
|
|
#include <QtCore/qscopedpointer.h>
|
|
|
|
QT_BEGIN_NAMESPACE
|
|
|
|
|
|
class Q_CORE_EXPORT QXmlStreamStringRef {
|
|
QString m_string;
|
|
int m_position, m_size;
|
|
public:
|
|
inline QXmlStreamStringRef():m_position(0), m_size(0){}
|
|
inline QXmlStreamStringRef(const QStringRef &aString)
|
|
:m_string(aString.string()?*aString.string():QString()), m_position(aString.position()), m_size(aString.size()){}
|
|
QXmlStreamStringRef(const QString &aString) : m_string(aString), m_position(0), m_size(m_string.size()) {}
|
|
#ifdef Q_COMPILER_RVALUE_REFS
|
|
QXmlStreamStringRef(QString &&aString) Q_DECL_NOTHROW : m_string(std::move(aString)), m_position(0), m_size(m_string.size()) {}
|
|
#endif
|
|
|
|
#if QT_VERSION < QT_VERSION_CHECK(6,0,0)
|
|
QXmlStreamStringRef(const QXmlStreamStringRef &other) // = default
|
|
: m_string(other.m_string), m_position(other.m_position), m_size(other.m_size) {}
|
|
#ifdef Q_COMPILER_RVALUE_REFS
|
|
QXmlStreamStringRef(QXmlStreamStringRef &&other) Q_DECL_NOTHROW // = default
|
|
: m_string(std::move(other.m_string)), m_position(other.m_position), m_size(other.m_size) {}
|
|
QXmlStreamStringRef &operator=(QXmlStreamStringRef &&other) Q_DECL_NOTHROW // = default
|
|
{ swap(other); return *this; }
|
|
#endif
|
|
QXmlStreamStringRef &operator=(const QXmlStreamStringRef &other) // = default
|
|
{ m_string = other.m_string; m_position = other.m_position; m_size = other.m_size; return *this; }
|
|
inline ~QXmlStreamStringRef() {} // ### this prevents (or deprecates) all the move/copy special member functions,
|
|
// ### that's why we need to provide them by hand above. We can't remove it in
|
|
// ### Qt 5, since that would change the way its passed to functions. In Qt 6, remove all.
|
|
#endif // Qt < 6.0
|
|
|
|
void swap(QXmlStreamStringRef &other) Q_DECL_NOTHROW
|
|
{
|
|
qSwap(m_string, other.m_string);
|
|
qSwap(m_position, other.m_position);
|
|
qSwap(m_size, other.m_size);
|
|
}
|
|
|
|
inline void clear() { m_string.clear(); m_position = m_size = 0; }
|
|
inline operator QStringRef() const { return QStringRef(&m_string, m_position, m_size); }
|
|
inline const QString *string() const { return &m_string; }
|
|
inline int position() const { return m_position; }
|
|
inline int size() const { return m_size; }
|
|
};
|
|
Q_DECLARE_SHARED_NOT_MOVABLE_UNTIL_QT6(QXmlStreamStringRef)
|
|
|
|
|
|
class QXmlStreamReaderPrivate;
|
|
class QXmlStreamAttributes;
|
|
class Q_CORE_EXPORT QXmlStreamAttribute {
|
|
QXmlStreamStringRef m_name, m_namespaceUri, m_qualifiedName, m_value;
|
|
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
|
|
void *reserved;
|
|
#endif
|
|
uint m_isDefault : 1;
|
|
friend class QXmlStreamReaderPrivate;
|
|
friend class QXmlStreamAttributes;
|
|
public:
|
|
QXmlStreamAttribute();
|
|
QXmlStreamAttribute(const QString &qualifiedName, const QString &value);
|
|
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
|
|
QXmlStreamAttribute(const QString &namespaceUri, const QString &name, const QString &value);
|
|
QXmlStreamAttribute(const QXmlStreamAttribute &);
|
|
#ifdef Q_COMPILER_RVALUE_REFS
|
|
QXmlStreamAttribute(QXmlStreamAttribute &&other) Q_DECL_NOTHROW // = default;
|
|
: m_name(std::move(other.m_name)),
|
|
m_namespaceUri(std::move(other.m_namespaceUri)),
|
|
m_qualifiedName(std::move(other.m_qualifiedName)),
|
|
m_value(std::move(other.m_value)),
|
|
reserved(other.reserved),
|
|
m_isDefault(other.m_isDefault)
|
|
{
|
|
other.reserved = Q_NULLPTR;
|
|
}
|
|
QXmlStreamAttribute &operator=(QXmlStreamAttribute &&other) Q_DECL_NOTHROW // = default;
|
|
{
|
|
m_name = std::move(other.m_name);
|
|
m_namespaceUri = std::move(other.m_namespaceUri);
|
|
m_qualifiedName = std::move(other.m_qualifiedName);
|
|
m_value = std::move(other.m_value);
|
|
qSwap(reserved, other.reserved);
|
|
m_isDefault = other.m_isDefault;
|
|
return *this;
|
|
}
|
|
#endif
|
|
QXmlStreamAttribute& operator=(const QXmlStreamAttribute &);
|
|
~QXmlStreamAttribute();
|
|
#endif // < Qt 6
|
|
|
|
inline QStringRef namespaceUri() const { return m_namespaceUri; }
|
|
inline QStringRef name() const { return m_name; }
|
|
inline QStringRef qualifiedName() const { return m_qualifiedName; }
|
|
inline QStringRef prefix() const {
|
|
return QStringRef(m_qualifiedName.string(),
|
|
m_qualifiedName.position(),
|
|
qMax(0, m_qualifiedName.size() - m_name.size() - 1));
|
|
}
|
|
inline QStringRef value() const { return m_value; }
|
|
inline bool isDefault() const { return m_isDefault; }
|
|
inline bool operator==(const QXmlStreamAttribute &other) const {
|
|
return (value() == other.value()
|
|
&& (namespaceUri().isNull() ? (qualifiedName() == other.qualifiedName())
|
|
: (namespaceUri() == other.namespaceUri() && name() == other.name())));
|
|
}
|
|
inline bool operator!=(const QXmlStreamAttribute &other) const
|
|
{ return !operator==(other); }
|
|
};
|
|
|
|
Q_DECLARE_TYPEINFO(QXmlStreamAttribute, Q_MOVABLE_TYPE);
|
|
|
|
class Q_CORE_EXPORT QXmlStreamAttributes : public QVector<QXmlStreamAttribute>
|
|
{
|
|
public:
|
|
inline QXmlStreamAttributes() {}
|
|
QStringRef value(const QString &namespaceUri, const QString &name) const;
|
|
QStringRef value(const QString &namespaceUri, QLatin1String name) const;
|
|
QStringRef value(QLatin1String namespaceUri, QLatin1String name) const;
|
|
QStringRef value(const QString &qualifiedName) const;
|
|
QStringRef value(QLatin1String qualifiedName) const;
|
|
void append(const QString &namespaceUri, const QString &name, const QString &value);
|
|
void append(const QString &qualifiedName, const QString &value);
|
|
|
|
inline bool hasAttribute(const QString &qualifiedName) const
|
|
{
|
|
return !value(qualifiedName).isNull();
|
|
}
|
|
|
|
inline bool hasAttribute(QLatin1String qualifiedName) const
|
|
{
|
|
return !value(qualifiedName).isNull();
|
|
}
|
|
|
|
inline bool hasAttribute(const QString &namespaceUri, const QString &name) const
|
|
{
|
|
return !value(namespaceUri, name).isNull();
|
|
}
|
|
|
|
using QVector<QXmlStreamAttribute>::append;
|
|
};
|
|
|
|
class Q_CORE_EXPORT QXmlStreamNamespaceDeclaration {
|
|
QXmlStreamStringRef m_prefix, m_namespaceUri;
|
|
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
|
|
void *reserved;
|
|
#endif
|
|
|
|
friend class QXmlStreamReaderPrivate;
|
|
public:
|
|
QXmlStreamNamespaceDeclaration();
|
|
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
|
|
QXmlStreamNamespaceDeclaration(const QXmlStreamNamespaceDeclaration &);
|
|
QXmlStreamNamespaceDeclaration(QXmlStreamNamespaceDeclaration &&other) Q_DECL_NOTHROW // = default
|
|
: m_prefix(std::move(other.m_prefix)),
|
|
m_namespaceUri(std::move(other.m_namespaceUri)),
|
|
reserved(other.reserved)
|
|
{
|
|
other.reserved = nullptr;
|
|
}
|
|
QXmlStreamNamespaceDeclaration &operator=(QXmlStreamNamespaceDeclaration &&other) Q_DECL_NOTHROW // = default
|
|
{
|
|
m_prefix = std::move(other.m_prefix);
|
|
m_namespaceUri = std::move(other.m_namespaceUri);
|
|
qSwap(reserved, other.reserved);
|
|
return *this;
|
|
}
|
|
QXmlStreamNamespaceDeclaration(const QString &prefix, const QString &namespaceUri);
|
|
~QXmlStreamNamespaceDeclaration();
|
|
QXmlStreamNamespaceDeclaration& operator=(const QXmlStreamNamespaceDeclaration &);
|
|
#endif // < Qt 6
|
|
|
|
inline QStringRef prefix() const { return m_prefix; }
|
|
inline QStringRef namespaceUri() const { return m_namespaceUri; }
|
|
inline bool operator==(const QXmlStreamNamespaceDeclaration &other) const {
|
|
return (prefix() == other.prefix() && namespaceUri() == other.namespaceUri());
|
|
}
|
|
inline bool operator!=(const QXmlStreamNamespaceDeclaration &other) const
|
|
{ return !operator==(other); }
|
|
};
|
|
|
|
Q_DECLARE_TYPEINFO(QXmlStreamNamespaceDeclaration, Q_MOVABLE_TYPE);
|
|
typedef QVector<QXmlStreamNamespaceDeclaration> QXmlStreamNamespaceDeclarations;
|
|
|
|
class Q_CORE_EXPORT QXmlStreamNotationDeclaration {
|
|
QXmlStreamStringRef m_name, m_systemId, m_publicId;
|
|
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
|
|
void *reserved;
|
|
#endif
|
|
|
|
friend class QXmlStreamReaderPrivate;
|
|
public:
|
|
QXmlStreamNotationDeclaration();
|
|
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
|
|
~QXmlStreamNotationDeclaration();
|
|
QXmlStreamNotationDeclaration(const QXmlStreamNotationDeclaration &);
|
|
QXmlStreamNotationDeclaration(QXmlStreamNotationDeclaration &&other) Q_DECL_NOTHROW // = default
|
|
: m_name(std::move(other.m_name)),
|
|
m_systemId(std::move(other.m_systemId)),
|
|
m_publicId(std::move(other.m_publicId)),
|
|
reserved(other.reserved)
|
|
{
|
|
other.reserved = nullptr;
|
|
}
|
|
QXmlStreamNotationDeclaration& operator=(const QXmlStreamNotationDeclaration &);
|
|
QXmlStreamNotationDeclaration &operator=(QXmlStreamNotationDeclaration &&other) Q_DECL_NOTHROW // = default
|
|
{
|
|
m_name = std::move(other.m_name);
|
|
m_systemId = std::move(other.m_systemId);
|
|
m_publicId = std::move(other.m_publicId);
|
|
qSwap(reserved, other.reserved);
|
|
return *this;
|
|
}
|
|
#endif // < Qt 6
|
|
|
|
inline QStringRef name() const { return m_name; }
|
|
inline QStringRef systemId() const { return m_systemId; }
|
|
inline QStringRef publicId() const { return m_publicId; }
|
|
inline bool operator==(const QXmlStreamNotationDeclaration &other) const {
|
|
return (name() == other.name() && systemId() == other.systemId()
|
|
&& publicId() == other.publicId());
|
|
}
|
|
inline bool operator!=(const QXmlStreamNotationDeclaration &other) const
|
|
{ return !operator==(other); }
|
|
};
|
|
|
|
Q_DECLARE_TYPEINFO(QXmlStreamNotationDeclaration, Q_MOVABLE_TYPE);
|
|
typedef QVector<QXmlStreamNotationDeclaration> QXmlStreamNotationDeclarations;
|
|
|
|
class Q_CORE_EXPORT QXmlStreamEntityDeclaration {
|
|
QXmlStreamStringRef m_name, m_notationName, m_systemId, m_publicId, m_value;
|
|
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
|
|
void *reserved;
|
|
#endif
|
|
|
|
friend class QXmlStreamReaderPrivate;
|
|
public:
|
|
QXmlStreamEntityDeclaration();
|
|
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
|
|
~QXmlStreamEntityDeclaration();
|
|
QXmlStreamEntityDeclaration(const QXmlStreamEntityDeclaration &);
|
|
QXmlStreamEntityDeclaration(QXmlStreamEntityDeclaration &&other) Q_DECL_NOTHROW // = default
|
|
: m_name(std::move(other.m_name)),
|
|
m_notationName(std::move(other.m_notationName)),
|
|
m_systemId(std::move(other.m_systemId)),
|
|
m_publicId(std::move(other.m_publicId)),
|
|
m_value(std::move(other.m_value)),
|
|
reserved(other.reserved)
|
|
{
|
|
other.reserved = nullptr;
|
|
}
|
|
QXmlStreamEntityDeclaration& operator=(const QXmlStreamEntityDeclaration &);
|
|
QXmlStreamEntityDeclaration &operator=(QXmlStreamEntityDeclaration &&other) Q_DECL_NOTHROW // = default
|
|
{
|
|
m_name = std::move(other.m_name);
|
|
m_notationName = std::move(other.m_notationName);
|
|
m_systemId = std::move(other.m_systemId);
|
|
m_publicId = std::move(other.m_publicId);
|
|
m_value = std::move(other.m_value);
|
|
qSwap(reserved, other.reserved);
|
|
return *this;
|
|
}
|
|
#endif // < Qt 6
|
|
|
|
inline QStringRef name() const { return m_name; }
|
|
inline QStringRef notationName() const { return m_notationName; }
|
|
inline QStringRef systemId() const { return m_systemId; }
|
|
inline QStringRef publicId() const { return m_publicId; }
|
|
inline QStringRef value() const { return m_value; }
|
|
inline bool operator==(const QXmlStreamEntityDeclaration &other) const {
|
|
return (name() == other.name()
|
|
&& notationName() == other.notationName()
|
|
&& systemId() == other.systemId()
|
|
&& publicId() == other.publicId()
|
|
&& value() == other.value());
|
|
}
|
|
inline bool operator!=(const QXmlStreamEntityDeclaration &other) const
|
|
{ return !operator==(other); }
|
|
};
|
|
|
|
Q_DECLARE_TYPEINFO(QXmlStreamEntityDeclaration, Q_MOVABLE_TYPE);
|
|
typedef QVector<QXmlStreamEntityDeclaration> QXmlStreamEntityDeclarations;
|
|
|
|
|
|
class Q_CORE_EXPORT QXmlStreamEntityResolver
|
|
{
|
|
public:
|
|
virtual ~QXmlStreamEntityResolver();
|
|
virtual QString resolveEntity(const QString& publicId, const QString& systemId);
|
|
virtual QString resolveUndeclaredEntity(const QString &name);
|
|
};
|
|
|
|
#ifndef QT_NO_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);
|
|
explicit QXmlStreamReader(const QByteArray &data);
|
|
explicit QXmlStreamReader(const QString &data);
|
|
explicit QXmlStreamReader(const char * data);
|
|
~QXmlStreamReader();
|
|
|
|
void setDevice(QIODevice *device);
|
|
QIODevice *device() const;
|
|
void addData(const QByteArray &data);
|
|
void addData(const QString &data);
|
|
void addData(const char *data);
|
|
void clear();
|
|
|
|
|
|
bool atEnd() const;
|
|
TokenType readNext();
|
|
|
|
bool readNextStartElement();
|
|
void skipCurrentElement();
|
|
|
|
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;
|
|
QStringRef documentVersion() const;
|
|
QStringRef documentEncoding() const;
|
|
|
|
qint64 lineNumber() const;
|
|
qint64 columnNumber() const;
|
|
qint64 characterOffset() const;
|
|
|
|
QXmlStreamAttributes attributes() const;
|
|
|
|
enum ReadElementTextBehaviour {
|
|
ErrorOnUnexpectedElement,
|
|
IncludeChildElements,
|
|
SkipChildElements
|
|
};
|
|
QString readElementText(ReadElementTextBehaviour behaviour = ErrorOnUnexpectedElement);
|
|
|
|
QStringRef name() const;
|
|
QStringRef namespaceUri() const;
|
|
QStringRef qualifiedName() const;
|
|
QStringRef prefix() const;
|
|
|
|
QStringRef processingInstructionTarget() const;
|
|
QStringRef processingInstructionData() const;
|
|
|
|
QStringRef text() const;
|
|
|
|
QXmlStreamNamespaceDeclarations namespaceDeclarations() const;
|
|
void addExtraNamespaceDeclaration(const QXmlStreamNamespaceDeclaration &extraNamespaceDeclaraction);
|
|
void addExtraNamespaceDeclarations(const QXmlStreamNamespaceDeclarations &extraNamespaceDeclaractions);
|
|
QXmlStreamNotationDeclarations notationDeclarations() const;
|
|
QXmlStreamEntityDeclarations entityDeclarations() const;
|
|
QStringRef dtdName() const;
|
|
QStringRef dtdPublicId() const;
|
|
QStringRef dtdSystemId() const;
|
|
|
|
|
|
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:
|
|
Q_DISABLE_COPY(QXmlStreamReader)
|
|
Q_DECLARE_PRIVATE(QXmlStreamReader)
|
|
QScopedPointer<QXmlStreamReaderPrivate> d_ptr;
|
|
|
|
};
|
|
#endif // QT_NO_XMLSTREAMREADER
|
|
|
|
#ifndef QT_NO_XMLSTREAMWRITER
|
|
|
|
class QXmlStreamWriterPrivate;
|
|
|
|
class Q_CORE_EXPORT QXmlStreamWriter
|
|
{
|
|
QDOC_PROPERTY(bool autoFormatting READ autoFormatting WRITE setAutoFormatting)
|
|
QDOC_PROPERTY(int autoFormattingIndent READ autoFormattingIndent WRITE setAutoFormattingIndent)
|
|
public:
|
|
QXmlStreamWriter();
|
|
explicit QXmlStreamWriter(QIODevice *device);
|
|
explicit QXmlStreamWriter(QByteArray *array);
|
|
explicit QXmlStreamWriter(QString *string);
|
|
~QXmlStreamWriter();
|
|
|
|
void setDevice(QIODevice *device);
|
|
QIODevice *device() const;
|
|
|
|
#ifndef QT_NO_TEXTCODEC
|
|
void setCodec(QTextCodec *codec);
|
|
void setCodec(const char *codecName);
|
|
QTextCodec *codec() const;
|
|
#endif
|
|
|
|
void setAutoFormatting(bool);
|
|
bool autoFormatting() const;
|
|
|
|
void setAutoFormattingIndent(int spacesOrTabs);
|
|
int autoFormattingIndent() const;
|
|
|
|
void writeAttribute(const QString &qualifiedName, const QString &value);
|
|
void writeAttribute(const QString &namespaceUri, const QString &name, const QString &value);
|
|
void writeAttribute(const QXmlStreamAttribute& attribute);
|
|
void writeAttributes(const QXmlStreamAttributes& attributes);
|
|
|
|
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);
|
|
|
|
void writeEndDocument();
|
|
void writeEndElement();
|
|
|
|
void writeEntityReference(const QString &name);
|
|
void writeNamespace(const QString &namespaceUri, const QString &prefix = QString());
|
|
void writeDefaultNamespace(const QString &namespaceUri);
|
|
void writeProcessingInstruction(const QString &target, const QString &data = QString());
|
|
|
|
void writeStartDocument();
|
|
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);
|
|
|
|
#ifndef QT_NO_XMLSTREAMREADER
|
|
void writeCurrentToken(const QXmlStreamReader &reader);
|
|
#endif
|
|
|
|
bool hasError() const;
|
|
|
|
private:
|
|
Q_DISABLE_COPY(QXmlStreamWriter)
|
|
Q_DECLARE_PRIVATE(QXmlStreamWriter)
|
|
QScopedPointer<QXmlStreamWriterPrivate> d_ptr;
|
|
};
|
|
#endif // QT_NO_XMLSTREAMWRITER
|
|
|
|
QT_END_NAMESPACE
|
|
|
|
#endif // QT_NO_XMLSTREAM
|
|
#endif // QXMLSTREAM_H
|