|  | Home · Overviews · Examples

# QXmlSimpleReader Class Reference
[com.trolltech.qt.xml module]

The `QXmlSimpleReader` class provides an implementation of a simple XML parser. More...

Inherits `QXmlReader`.

## Detailed Description

The `QXmlSimpleReader` class provides an implementation of a simple XML parser.

This XML reader is suitable for a wide range of applications. It is able to parse well-formed XML and can report the namespaces of elements to a content handler; however, it does not parse any external entities. For historical reasons, Attribute Value Normalization and End-of-Line Handling as described in the XML 1.0 specification is not performed.

The easiest pattern of use for this class is to create a reader instance, define an input source, specify the handlers to be used by the reader, and parse the data.

For example, we could use a `QFile` to supply the input. Here, we create a reader, and define an input source to be used by the reader:

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

A handler lets us perform actions when the reader encounters certain types of content, or if errors in the input are found. The reader must be told which handler to use for each type of event. For many common applications, we can create a custom handler by subclassing `QXmlDefaultHandler`, and use this to handle both error and content events:

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

If you don't set at least the content and error handlers, the parser will fall back on its default behavior---and will do nothing.

The most convenient way to handle the input is to read it in a single pass using the `parse` function with an argument that specifies the input source:

            bool ok = xmlReader.parse(source);

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

If you can't parse the entire input in one go (for example, it is huge, or is being delivered over a network connection), data can be fed to the parser in pieces. This is achieved by telling `parse` to work incrementally, and making subsequent calls to the `parseContinue` function, until all the data has been processed.

A common way to perform incremental parsing is to connect the `readyRead()` signal of the input source to a slot, and handle the incoming data there. For example, the following code shows how a parser for RSS feeds can be used to incrementally parse data that it receives from a `QHttp` object:

        void RSSListing::readData(const QHttpResponseHeader &resp)
        {
            bool ok;

            if (resp.statusCode() != 200)
                http.abort();
            else {
                xmlInput.setData(http.readAll());

                if (newInformation) {
                    ok = xmlReader.parse(&xmlInput, true);
                    newInformation = false;
                }
                else
                    ok = xmlReader.parseContinue();

                if (!ok)
                    http.abort();
            }
        }

Aspects of the parsing behavior can be adapted using `setFeature` and setProperty(). For example, the following code could be used to enable reporting of namespace prefixes to the content handler:

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