En esta página

QXmlSimpleReader Class

La clase QXmlSimpleReader ofrece una implementación de un analizador XML sencillo. Más información...

Encabezado: #include <QXmlSimpleReader>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core5Compat)
target_link_libraries(mytarget PRIVATE Qt6::Core5Compat)
qmake: QT += core5compat
Heredan de: QXmlReader

Advertencia: Esta clase no es reentrante.

Funciones públicas

QXmlSimpleReader()
virtual ~QXmlSimpleReader()
virtual bool parse(const QXmlInputSource *input, bool incremental)
virtual bool parseContinue()

Funciones públicas reimplementadas

virtual QXmlDTDHandler *DTDHandler() const override
virtual QXmlContentHandler *contentHandler() const override
virtual QXmlDeclHandler *declHandler() const override
virtual QXmlEntityResolver *entityResolver() const override
virtual QXmlErrorHandler *errorHandler() const override
virtual bool feature(const QString &name, bool *ok = nullptr) const override
virtual bool hasFeature(const QString &name) const override
virtual bool hasProperty(const QString &name) const override
virtual QXmlLexicalHandler *lexicalHandler() const override
virtual bool parse(const QXmlInputSource &input) override
virtual bool parse(const QXmlInputSource *input) override
virtual void *property(const QString &name, bool *ok = nullptr) const override
virtual void setContentHandler(QXmlContentHandler *handler) override
virtual void setDTDHandler(QXmlDTDHandler *handler) override
virtual void setDeclHandler(QXmlDeclHandler *handler) override
virtual void setEntityResolver(QXmlEntityResolver *handler) override
virtual void setErrorHandler(QXmlErrorHandler *handler) override
virtual void setFeature(const QString &name, bool enable) override
virtual void setLexicalHandler(QXmlLexicalHandler *handler) override
virtual void setProperty(const QString &name, void *value) override

Descripción detallada

Este lector de XML es adecuado para una amplia gama de aplicaciones. Es capaz de analizar XML bien formado y puede informar de los espacios de nombres de los elementos a un gestor de contenido; sin embargo, no analiza ninguna entidad externa. Por razones históricas, no se llevan a cabo la normalización de valores de atributos ni el tratamiento de los finales de línea tal y como se describen en la especificación XML 1.0.

La forma más sencilla de utilizar esta clase es crear una instancia del lector, definir una fuente de entrada, especificar los gestores que utilizará el lector y analizar los datos.

Por ejemplo, podríamos utilizar un ` QFile ` para proporcionar la entrada. En este caso, creamos un lector y definimos una fuente de entrada que utilizará el lector:

    QXmlSimpleReader xmlReader;
    QXmlInputSource *source = new QXmlInputSource(file);

Un controlador nos permite realizar acciones cuando el lector encuentra determinados tipos de contenido o si se detectan errores en la entrada. Es necesario indicar al lector qué controlador debe utilizar para cada tipo de evento. Para muchas aplicaciones comunes, podemos crear un controlador personalizado creando una subclase de ` QXmlDefaultHandler` y utilizarlo para gestionar tanto los eventos de error como los de contenido:

    Handler *handler = new Handler;
    xmlReader.setContentHandler(handler);
    xmlReader.setErrorHandler(handler);

Si no se configuran al menos los controladores de contenido y de error, el analizador recurrirá a su comportamiento por defecto y no hará nada.

La forma más cómoda de gestionar la entrada es leerla en una sola pasada utilizando la función ` parse()` con un argumento que especifique la fuente de entrada:

    bool ok = xmlReader.parse(source);

    if (!ok)
        std::cout << "Parsing failed." << std::endl;

Si no puedes analizar toda la entrada de una sola vez (por ejemplo, porque es muy grande o se está recibiendo a través de una conexión de red), los datos se pueden enviar al analizador por partes. Esto se consigue indicando a parse() que trabaje de forma incremental y realizando llamadas sucesivas a la función parseContinue(), hasta que se hayan procesado todos los datos.

Una forma habitual de realizar un análisis incremental es conectar la señal readyRead() de un network reply a un slot y gestionar allí los datos entrantes. Véase QNetworkAccessManager.

Se pueden adaptar aspectos del comportamiento del análisis mediante setFeature() y setProperty().

xmlReader.setFeature("http://xml.org/sax/features/namespace-prefixes", true);

QXmlSimpleReader no es reentrante. Si desea utilizar la clase en código multihilo, bloquee el código que utiliza QXmlSimpleReader con un mecanismo de bloqueo, como QMutex.

Ten en cuenta que esta clase ya está obsoleta; utiliza QXmlStreamReader o QDomDocument para leer archivos XML.

Documentación de las funciones miembro

QXmlSimpleReader::QXmlSimpleReader()

Crea un lector de XML sencillo.

[virtual noexcept] QXmlSimpleReader::~QXmlSimpleReader()

Elimina el lector de XML sencillo.

[override virtual] QXmlDTDHandler *QXmlSimpleReader::DTDHandler() const

Reimplementa: QXmlReader::DTDHandler() const.

Véase también setDTDHandler().

[override virtual] QXmlContentHandler *QXmlSimpleReader::contentHandler() const

Reimplementa: QXmlReader::contentHandler() const.

Véase también setContentHandler().

[override virtual] QXmlDeclHandler *QXmlSimpleReader::declHandler() const

Reimplementa: QXmlReader::declHandler() const.

Véase también setDeclHandler().

[override virtual] QXmlEntityResolver *QXmlSimpleReader::entityResolver() const

Reimplementa: ` QXmlReader::entityResolver()` const.

Véase también setEntityResolver().

[override virtual] QXmlErrorHandler *QXmlSimpleReader::errorHandler() const

Reimplementa: QXmlReader::errorHandler() const.

Véase también setErrorHandler().

[override virtual] bool QXmlSimpleReader::feature(const QString &name, bool *ok = nullptr) const

Reimplementa: QXmlReader::feature(const QString &name, bool *ok) const.

Véase también setFeature().

[override virtual] bool QXmlSimpleReader::hasFeature(const QString &name) const

Reimplementa: QXmlReader::hasFeature(const QString &name) const.

[override virtual] bool QXmlSimpleReader::hasProperty(const QString &name) const

Reimplementa: ` QXmlReader::hasProperty(const QString &name) const`.

[override virtual] QXmlLexicalHandler *QXmlSimpleReader::lexicalHandler() const

Reimplementa: ` QXmlReader::lexicalHandler()` const.

Véase también setLexicalHandler().

[override virtual] bool QXmlSimpleReader::parse(const QXmlInputSource &input)

Reimplementa: ` QXmlReader::parse(const QXmlInputSource &input)`.

[override virtual] bool QXmlSimpleReader::parse(const QXmlInputSource *input)

Reimplementa: QXmlReader::parse(const QXmlInputSource *input).

Lee un documento XML desde ` input ` y lo analiza en una sola pasada (de forma no incremental). Devuelve ` true ` si el análisis se ha realizado correctamente; en caso contrario, devuelve ` false`.

[virtual] bool QXmlSimpleReader::parse(const QXmlInputSource *input, bool incremental)

Lee un documento XML desde input y lo analiza. Devuelve true si el análisis se ha completado correctamente; en caso contrario, devuelve false, lo que indica que se ha producido un error.

Si incremental es falso, esta función devolverá falso si el archivo XML no se lee por completo. En este caso, no se puede continuar con el análisis.

Si incremental es verdadero, el analizador no devuelve falso si llega al final de input antes de llegar al final del archivo XML. En su lugar, almacena el estado del analizador para que el análisis pueda continuarse más tarde, cuando haya más datos disponibles. En tal caso, puede utilizar la función parseContinue() para continuar con el análisis. Esta clase almacena un puntero a la fuente de entrada input y la función parseContinue() intenta leer desde dicha fuente de entrada. Por lo tanto, no debe eliminar la fuente de entrada input hasta que ya no necesite llamar a parseContinue().

Si se llama a esta función con incremental establecido en «true» mientras se está realizando un análisis incremental, se iniciará una nueva sesión de análisis y se perderá la sesión anterior.

Véanse también parseContinue() y QTcpSocket.

[virtual] bool QXmlSimpleReader::parseContinue()

Continúa el análisis incremental, tomando la entrada del objeto ` QXmlInputSource ` que se especificó en la última llamada a ` parse()`. Para utilizar esta función, es necesario haber llamado a ` parse()` con el argumento «incremental» establecido en «true».

Devuelve ` false ` si se produce un error de análisis; en caso contrario, devuelve ` true`, incluso si no se ha llegado al final del archivo XML. Se puede continuar con el análisis en una fase posterior llamando de nuevo a esta función cuando haya más datos disponibles para analizar.

Llamar a esta función cuando no hay datos disponibles en la fuente de entrada indica al lector que se ha llegado al final del archivo XML. Si la entrada proporcionada hasta ese momento no estaba bien formada, se produce un error de análisis y se devuelve «false». Si la entrada proporcionada estaba bien formada, se devuelve «true». Es importante finalizar la entrada de esta manera, ya que permite reutilizar el lector para analizar otros archivos XML.

Llamar a esta función después de haber llegado al final del archivo, pero sin datos disponibles, provocará que se devuelva «false», independientemente de si la entrada anterior estaba bien formada o no.

Véase también parse(), QXmlInputSource::data() y QXmlInputSource::next().

[override virtual] void *QXmlSimpleReader::property(const QString &name, bool *ok = nullptr) const

Reimplementa: ` QXmlReader::property(const QString &name, bool *ok) const`.

Véase también setProperty().

[override virtual] void QXmlSimpleReader::setContentHandler(QXmlContentHandler *handler)

Reimplementa: QXmlReader::setContentHandler(QXmlContentHandler *handler).

Véase también contentHandler().

[override virtual] void QXmlSimpleReader::setDTDHandler(QXmlDTDHandler *handler)

Reimplementa: ` QXmlReader::setDTDHandler(QXmlDTDHandler *handler)`.

[override virtual] void QXmlSimpleReader::setDeclHandler(QXmlDeclHandler *handler)

Reimplementa: QXmlReader::setDeclHandler(QXmlDeclHandler *handler).

Véase también declHandler().

[override virtual] void QXmlSimpleReader::setEntityResolver(QXmlEntityResolver *handler)

Reimplementa: QXmlReader::setEntityResolver(QXmlEntityResolver *handler).

Véase también entityResolver().

[override virtual] void QXmlSimpleReader::setErrorHandler(QXmlErrorHandler *handler)

Reimplementa: QXmlReader::setErrorHandler(QXmlErrorHandler *handler).

Véase también errorHandler().

[override virtual] void QXmlSimpleReader::setFeature(const QString &name, bool enable)

Reimplementa: ` QXmlReader::setFeature` (`const QString &name, bool value`).

Activa la función « name » si « enable » es verdadero; en caso contrario, la desactiva.

El parámetro « name » debe ser una de las siguientes cadenas:

FunciónValor por defectoNotas
http://xml.org/sax/features/namespacestrueSi está habilitada, los espacios de nombres se comunican al gestor de contenido.
http://xml.org/sax/features/namespace-prefixesfalseSi se habilita, se informan los nombres y atributos originales con prefijo utilizados para las declaraciones de espacios de nombres.
http://qt-project.org/xml/features/report-whitespace-only-CharDatatrueSi está activada, los datos de caracteres (CharData) que constan únicamente de caracteres de espacio en blanco se notifican mediante la función « QXmlContentHandler::characters()». Si está desactivada, los espacios en blanco se descartan de forma silenciosa.
http://qt-project.org/xml/features/report-start-end-entityfalseSi está habilitado, el analizador informa de los eventos QXmlContentHandler::startEntity() y QXmlContentHandler::endEntity(), por lo que los datos de caracteres pueden informarse en bloques. Si está deshabilitado, el analizador no informa de estos eventos, sino que sustituye las entidades de forma silenciosa e informa de los datos de caracteres en un solo bloque.

Véase también feature() y hasFeature().

[override virtual] void QXmlSimpleReader::setLexicalHandler(QXmlLexicalHandler *handler)

Reimplementa: QXmlReader::setLexicalHandler(QXmlLexicalHandler *handler).

Véase también lexicalHandler().

[override virtual] void QXmlSimpleReader::setProperty(const QString &name, void *value)

Reimplementa: QXmlReader::setProperty(const QString &name, void *value).

Véase también property().

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.