Revision control
++ // Copyright (C) 2015 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
++
++ #include "qgeoroutexmlparser.h"
++
++ #include <QXmlStreamReader>
++ #include <QStringList>
++ #include <QString>
++ #include <QtCore/QThreadPool>
++ #include <QDebug>
++
++ #include <QtPositioning/QGeoRectangle>
++ #include <QtPositioning/QGeoPath>
++ #include <QtLocation/QGeoRoute>
++ #include <QtLocation/private/qgeoroutesegment_p.h>
++
++ QT_BEGIN_NAMESPACE
++
++ QGeoDynamicSpeedInfoContainer::QGeoDynamicSpeedInfoContainer()
++ : trafficSpeed(0)
++ , baseSpeed(0)
++ , trafficTime(0)
++ , baseTime(0)
++ {}
++
++ QGeoRouteXmlParser::QGeoRouteXmlParser(const QGeoRouteRequest &request)
++ : m_request(request)
++ {
++ }
++
++ QGeoRouteXmlParser::~QGeoRouteXmlParser()
++ {
++ }
++
++ void QGeoRouteXmlParser::parse(const QByteArray &data)
++ {
++ m_data = data;
++ // QFile file("/tmp/here.xml");
++ // file.open(QIODevice::WriteOnly);
++ // file.write(data);
++ // file.close();
++ QThreadPool::globalInstance()->start(this);
++ }
++
++ void QGeoRouteXmlParser::run()
++ {
++ m_reader = new QXmlStreamReader(m_data);
++
++ if (!parseRootElement())
++ emit errorOccurred(m_reader->errorString());
++ else
++ emit results(m_results);
++
++ delete m_reader;
++ m_reader = 0;
++ }
++
++ bool QGeoRouteXmlParser::parseRootElement()
++ {
++ if (!m_reader->readNextStartElement()) {
++ m_reader->raiseError(QStringLiteral("Expected a root element named \"CalculateRoute\" "
++ "(no root element found)."));
++ return false;
++ }
++
++ if (m_reader->name() == QLatin1String("Error")) {
++ QXmlStreamAttributes attributes = m_reader->attributes();
++ if (attributes.value(QStringLiteral("type")) == QLatin1String("ApplicationError")
++ && attributes.value("subtype") == QLatin1String("NoRouteFound"))
++ return true;
++ }
++
++ bool updateroute = false;
++ if (m_reader->name() != QLatin1String("CalculateRoute")
++ && m_reader->name() != QLatin1String("GetRoute")) {
++ m_reader->raiseError(QStringLiteral("The root element is expected to have the name "
++ "\"CalculateRoute\" or \"GetRoute\" (root element "
++ "was named \"%1\").").arg(m_reader->name().toString()));
++ return false;
++ } else if (m_reader->name() == QLatin1String("GetRoute")) {
++ updateroute = true;
++ }
++
++ if (m_reader->readNextStartElement()) {
++ if (m_reader->name() != QLatin1String("Response")) {
++ m_reader->raiseError(QStringLiteral("Expected a element named \"Response\" (element "
++ "was named \"%1\").").arg(m_reader->name().toString()));
++ return false;
++ }
++ }
++
++ while (m_reader->readNextStartElement() && !m_reader->hasError()) {
++ if (m_reader->name() == QLatin1String("Route")) {
++ QGeoRoute route;
++ route.setRequest(m_request);
++ if (updateroute)
++ route.setTravelMode(QGeoRouteRequest::TravelMode(int(m_request.travelModes())));
++ if (!parseRoute(&route))
++ continue; //route parsing failed move on to the next
++ m_results.append(route);
++ } else if (m_reader->name() == QLatin1String("Progress")) {
++ //TODO: updated route progress
++ m_reader->skipCurrentElement();
++ } else {
++ m_reader->skipCurrentElement();
++ }
++ }
++
++ return !m_reader->hasError();
++ }
++
++ bool QGeoRouteXmlParser::parseRoute(QGeoRoute *route)
++ {
++ Q_ASSERT(m_reader->isStartElement() && m_reader->name() == QLatin1String("Route"));
++ m_maneuvers.clear();
++ // m_segments.clear();
++ m_legs.clear();
++ int legIndex = 0;
++ m_reader->readNext();
++ while (!(m_reader->tokenType() == QXmlStreamReader::EndElement
++ && m_reader->name() == QLatin1String("Route")) && !m_reader->hasError()) {
++ if (m_reader->tokenType() == QXmlStreamReader::StartElement) {
++ if (m_reader->name() == QLatin1String("RouteId")) {
++ route->setRouteId(m_reader->readElementText());
++ }
++ //else if (m_reader->name() == "Waypoint") {
++ // succeeded = parseWaypoint(route);
++ //}
++ else if (m_reader->name() == QLatin1String("Mode")) {
++ if (!parseMode(route))
++ return false;
++ } else if (m_reader->name() == QLatin1String("Shape")) {
++ QString elementName = m_reader->name().toString();
++ QList<QGeoCoordinate> path;
++ if (!parseGeoPoints(m_reader->readElementText(), &path, elementName))
++ return false;
++ route->setPath(path);
++ } else if (m_reader->name() == QLatin1String("BoundingBox")) {
++ QGeoRectangle bounds;
++ if (!parseBoundingBox(bounds))
++ return false;
++ route->setBounds(bounds);
++ } else if (m_reader->name() == QLatin1String("Leg")) {
++ if (!parseLeg(legIndex++))
++ return false;
++ } else if (m_reader->name() == QLatin1String("Summary")) {
++ if (!parseSummary(route))
++ return false;
++ } else {
++ m_reader->skipCurrentElement();
++ }
++ }
++ m_reader->readNext();
++ }
++
++ if (m_reader->hasError())
++ return false;
++
++ return postProcessRoute(route);
++ }
++
++ bool QGeoRouteXmlParser::parseLeg(int legIndex)
++ {
++ Q_ASSERT(m_reader->isStartElement() && m_reader->name() == QStringLiteral("Leg"));
++ QGeoRoute leg;
++ leg.setLegIndex(legIndex);
++ m_reader->readNext();
++ QList<QGeoManeuverContainer> maneuvers;
++ QList<QGeoRouteSegmentContainer> links;
++ while (!(m_reader->tokenType() == QXmlStreamReader::EndElement
++ && m_reader->name() == QStringLiteral("Leg")) &&
++ !m_reader->hasError()) {
++ if (m_reader->tokenType() == QXmlStreamReader::StartElement) {
++ if (m_reader->name() == QStringLiteral("Maneuver")) {
++ if (!parseManeuver(maneuvers))
++ return false;
++ }
++ // Currently unused, after requesting shape attribute in maneuvers.
++ // Links, however, contain additional info, such as speed limits, and might become needed in the future.
++ // else if (m_reader->name() == QStringLiteral("Link")) {
++ // if (!parseLink(links))
++ // return false;
++ // }
++ else if (m_reader->name() == QLatin1String("TravelTime")) {
++ leg.setTravelTime(qRound(m_reader->readElementText().toDouble()));
++ } else if (m_reader->name() == QLatin1String("Length")) {
++ leg.setDistance(m_reader->readElementText().toDouble());
++ } else {
++ m_reader->skipCurrentElement();
++ }
++ }
++ m_reader->readNext();
++ }
++
++ if (m_reader->hasError())
++ return false;
++
++ m_legs << leg;
++ // m_segments << links;
++ m_maneuvers << maneuvers;
++ return true;
++ }
++
++ bool QGeoRouteXmlParser::postProcessRoute(QGeoRoute *route)
++ {
++ QList<QList<QGeoRouteSegment>> legSegments;
++ Q_ASSERT(m_maneuvers.size());
++
++
++ // Step 3: populate the linkMap, linkId -> linkContainer
++ for (qsizetype i = 0; i < m_maneuvers.size(); i++) {
++ legSegments << QList<QGeoRouteSegment>();
++ QList<QGeoRouteSegment> &segments = legSegments[i];
++ QList<QGeoManeuverContainer> &maneuvers = m_maneuvers[i];
++ for (qsizetype j = 0; j < m_maneuvers.at(i).size(); j++) {
++ QGeoManeuverContainer &maneuver = maneuvers[j];
++ QGeoRouteSegment segment;
++
++ QVariantMap extendedAttributes;
++ extendedAttributes["first"] = maneuver.first;
++ extendedAttributes["last"] = maneuver.last;
++ extendedAttributes["legIndex"] = i;
++ extendedAttributes["id"] = maneuver.id;
++ extendedAttributes["toLink"] = maneuver.toLink;
++ extendedAttributes["index"] = j;
++ maneuver.maneuver.setExtendedAttributes(extendedAttributes);
++
++ segment.setDistance(maneuver.maneuver.distanceToNextInstruction());
++ segment.setTravelTime(maneuver.maneuver.timeToNextInstruction());
++ segment.setPath(maneuver.path);
++ segment.setManeuver(maneuver.maneuver);
++ segments << segment;
++ }
++ }
++
++ // Step 7: connect all segments.
++ QGeoRouteSegment segment;
++ QGeoRouteSegment firstSegment;
++ for (auto &segments: legSegments) {
++ for (qsizetype j = 0; j < segments.size(); j++) {
++ if (segment.isValid()) {
++ segment.setNextRouteSegment(segments[j]);
++ } else {
++ firstSegment = segments[j];
++ }
++ segment = segments[j];
++ if (j == segments.size() - 1) {
++ QGeoRouteSegmentPrivate *sp = QGeoRouteSegmentPrivate::get(segment);
++ sp->setLegLastSegment(true);
++ }
++ }
++ }
++
++ if (firstSegment.isValid())
++ route->setFirstRouteSegment(firstSegment);
++
++ // Step 8: fill route legs.
++ for (qsizetype i = 0; i < m_legs.size(); i++) {
++ auto &leg = m_legs[i];
++ leg.setTravelMode(route->travelMode());
++ leg.setRequest(route->request());
++ leg.setOverallRoute(*route);
++ leg.setLegIndex(i);
++
++ leg.setFirstRouteSegment(legSegments[i].first());
++
++ // handle path
++ QList<QGeoCoordinate> path;
++ QGeoRouteSegment s = leg.firstRouteSegment();
++ while (s.isValid()) {
++ path.append(s.path());
++ if (s.isLegLastSegment())
++ break;
++ s = s.nextRouteSegment();
++ }
++ leg.setPath(path);
++ leg.setBounds(QGeoPath(path).boundingGeoRectangle());
++ }
++ route->setRouteLegs(m_legs);
++ m_legs.clear();
++ // m_segments.clear();
++ m_maneuvers.clear();
++ return true;
++ }
++
++ /*
++ bool QGeoRouteXmlParser::parseWaypoint(QGeoRoute *route)
++ {
++ Q_ASSERT(m_reader->isStartElement() && m_reader->name() == "Waypoint");
++ m_reader->readNext();
++ QList<QGeoCoordinate> path(route->pathSummary());
++
++ while (!(m_reader->tokenType() == QXmlStreamReader::EndElement && m_reader->name() == "Waypoint")) {
++ if (m_reader->tokenType() == QXmlStreamReader::StartElement) {
++ if (m_reader->name() == "MappedPosition") {
++ QGeoCoordinate coordinates;
++ if(!parseCoordinates(coordinates))
++ return false;
++ path.append(coordinates);
++ }
++ else {
++ m_reader->skipCurrentElement();
++ }
++ }
++ m_reader->readNext();
++ }
++ route->setPathSummary(path);
++ return true;
++ }
++ */
++
++ bool QGeoRouteXmlParser::parseMode(QGeoRoute *route)
++ {
++ Q_ASSERT(m_reader->isStartElement() && m_reader->name() == QLatin1String("Mode"));
++ m_reader->readNext();
++
++ while (!(m_reader->tokenType() == QXmlStreamReader::EndElement
++ && m_reader->name() == QLatin1String("Mode")) && !m_reader->hasError()) {
++ if (m_reader->tokenType() == QXmlStreamReader::StartElement) {
++ if (m_reader->name() == QLatin1String("TransportModes")) {
++ QString value = m_reader->readElementText();
++ if (value == "car")
++ route->setTravelMode(QGeoRouteRequest::CarTravel);
++ else if (value == "pedestrian")
++ route->setTravelMode(QGeoRouteRequest::PedestrianTravel);
++ else if (value == "publicTransport")
++ route->setTravelMode(QGeoRouteRequest::PublicTransitTravel);
++ else if (value == "bicycle")
++ route->setTravelMode(QGeoRouteRequest::BicycleTravel);
++ else if (value == "truck")
++ route->setTravelMode(QGeoRouteRequest::TruckTravel);
++ else {
++ // unsupported mode
++ m_reader->raiseError(QString("Unsupported travel mode '\"%1\"'").arg(value));
++ return false;
++ }
++ } else {
++ m_reader->skipCurrentElement();
++ }
++ }
++ m_reader->readNext();
++ }
++ return !m_reader->hasError();
++ }
++
++ bool QGeoRouteXmlParser::parseSummary(QGeoRoute *route)
++ {
++ Q_ASSERT(route);
++ Q_ASSERT(m_reader->isStartElement() && m_reader->name() == QLatin1String("Summary"));
++ m_reader->readNext();
++
++ double baseTime = -1, trafficTime = -1;
++
++ while (!(m_reader->tokenType() == QXmlStreamReader::EndElement
++ && m_reader->name() == QLatin1String("Summary")) && !m_reader->hasError()) {
++ if (m_reader->tokenType() == QXmlStreamReader::StartElement) {
++ if (m_reader->name() == QLatin1String("Distance")) {
++ route->setDistance(m_reader->readElementText().toDouble());
++ } else if (m_reader->name() == QLatin1String("TrafficTime")) {
++ trafficTime = m_reader->readElementText().toDouble();
++ } else if (m_reader->name() == QLatin1String("BaseTime")) {
++ baseTime = m_reader->readElementText().toDouble();
++ } else {
++ m_reader->skipCurrentElement();
++ }
++ }
++ m_reader->readNext();
++ }
++
++ if (m_reader->hasError())
++ return false;
++
++ if (trafficTime >= 0)
++ route->setTravelTime(trafficTime);
++ else if (baseTime >= 0)
++ route->setTravelTime(baseTime);
++
++ return true;
++ }
++
++ bool QGeoRouteXmlParser::parseCoordinates(QGeoCoordinate &coord)
++ {
++ QString currentElement = m_reader->name().toString();
++ m_reader->readNext();
++
++ while (!(m_reader->tokenType() == QXmlStreamReader::EndElement
++ && m_reader->name() == currentElement) && !m_reader->hasError()) {
++ if (m_reader->tokenType() == QXmlStreamReader::StartElement) {
++ QString name = m_reader->name().toString();
++ QString value = m_reader->readElementText();
++ if (name == "Latitude")
++ coord.setLatitude(value.toDouble());
++ else if (name == "Longitude")
++ coord.setLongitude(value.toDouble());
++ }
++ m_reader->readNext();
++ }
++
++ return !m_reader->hasError();
++ }
++
++ bool QGeoRouteXmlParser::parseManeuver(QList<QGeoManeuverContainer> &maneuvers)
++ {
++ Q_ASSERT(m_reader->isStartElement() && m_reader->name() == QLatin1String("Maneuver"));
++
++ if (!m_reader->attributes().hasAttribute("id")) {
++ m_reader->raiseError("The element \"Maneuver\" did not have the required attribute \"id\".");
++ return false;
++ }
++ QGeoManeuverContainer maneuverContainter;
++ maneuverContainter.id = m_reader->attributes().value("id").toString();
++
++ m_reader->readNext();
++ while (!(m_reader->tokenType() == QXmlStreamReader::EndElement
++ && m_reader->name() == QLatin1String("Maneuver")) && !m_reader->hasError()) {
++ if (m_reader->tokenType() == QXmlStreamReader::StartElement) {
++ if (m_reader->name() == QLatin1String("Position")) {
++ QGeoCoordinate coordinates;
++ if (parseCoordinates(coordinates))
++ maneuverContainter.maneuver.setPosition(coordinates);
++ } else if (m_reader->name() == QLatin1String("Instruction")) {
++ maneuverContainter.maneuver.setInstructionText(m_reader->readElementText());
++ } else if (m_reader->name() == QLatin1String("Shape")) {
++ QString elementName = m_reader->name().toString();
++ QList<QGeoCoordinate> path;
++ if (!parseGeoPoints(m_reader->readElementText(), &path, elementName))
++ return false;
++ maneuverContainter.path = path;
++ } else if (m_reader->name() == QLatin1String("ToLink")) {
++ maneuverContainter.toLink = m_reader->readElementText();
++ } else if (m_reader->name() == QLatin1String("TravelTime")) {
++ maneuverContainter.maneuver.setTimeToNextInstruction(qRound(m_reader->readElementText().toDouble()));
++ } else if (m_reader->name() == QLatin1String("Length")) {
++ maneuverContainter.maneuver.setDistanceToNextInstruction(m_reader->readElementText().toDouble());
++ } else if (m_reader->name() == QLatin1String("Direction")) {
++ QString value = m_reader->readElementText();
++ if (value == "forward")
++ maneuverContainter.maneuver.setDirection(QGeoManeuver::DirectionForward);
++ else if (value == "bearRight")
++ maneuverContainter.maneuver.setDirection(QGeoManeuver::DirectionBearRight);
++ else if (value == "lightRight")
++ maneuverContainter.maneuver.setDirection(QGeoManeuver::DirectionLightRight);
++ else if (value == "right")
++ maneuverContainter.maneuver.setDirection(QGeoManeuver::DirectionRight);
++ else if (value == "hardRight")
++ maneuverContainter.maneuver.setDirection(QGeoManeuver::DirectionHardRight);
++ else if (value == "uTurnRight")
++ maneuverContainter.maneuver.setDirection(QGeoManeuver::DirectionUTurnRight);
++ else if (value == "uTurnLeft")
++ maneuverContainter.maneuver.setDirection(QGeoManeuver::DirectionUTurnLeft);
++ else if (value == "hardLeft")
++ maneuverContainter.maneuver.setDirection(QGeoManeuver::DirectionHardLeft);
++ else if (value == "left")
++ maneuverContainter.maneuver.setDirection(QGeoManeuver::DirectionLeft);
++ else if (value == "lightLeft")
++ maneuverContainter.maneuver.setDirection(QGeoManeuver::DirectionLightLeft);
++ else if (value == "bearLeft")
++ maneuverContainter.maneuver.setDirection(QGeoManeuver::DirectionBearLeft);
++ else
++ maneuverContainter.maneuver.setDirection(QGeoManeuver::NoDirection);
++ } else {
++ m_reader->skipCurrentElement();
++ }
++ }
++ m_reader->readNext();
++ }
++
++ if (m_reader->hasError())
++ return false;
++
++ maneuvers.append(maneuverContainter);
++ return true;
++ }
++
++ bool QGeoRouteXmlParser::parseLink(QList<QGeoRouteSegmentContainer> &links)
++ {
++ Q_ASSERT(m_reader->isStartElement() && m_reader->name() == QStringLiteral("Link"));
++ m_reader->readNext();
++
++ QGeoRouteSegmentContainer segmentContainer;
++
++ while (!(m_reader->tokenType() == QXmlStreamReader::EndElement
++ && m_reader->name() == QStringLiteral("Link")) && !m_reader->hasError()) {
++ if (m_reader->tokenType() == QXmlStreamReader::StartElement) {
++ if (m_reader->name() == QStringLiteral("LinkId")) {
++ segmentContainer.id = m_reader->readElementText();
++ } else if (m_reader->name() == QStringLiteral("Shape")) {
++ QString elementName = m_reader->name().toString();
++ QList<QGeoCoordinate> path;
++ parseGeoPoints(m_reader->readElementText(), &path, elementName);
++ segmentContainer.segment.setPath(path);
++ } else if (m_reader->name() == QStringLiteral("Length")) {
++ segmentContainer.segment.setDistance(m_reader->readElementText().toDouble());
++ } else if (m_reader->name() == QStringLiteral("Maneuver")) {
++ segmentContainer.maneuverId = m_reader->readElementText();
++ } else if (m_reader->name() == QStringLiteral("DynamicSpeedInfo")) {
++ QGeoDynamicSpeedInfoContainer speedInfo;
++ if (!parseDynamicSpeedInfo(speedInfo))
++ return false;
++ const double time = speedInfo.trafficTime >= 0
++ ? speedInfo.trafficTime : speedInfo.baseTime;
++ if (time >= 0)
++ segmentContainer.segment.setTravelTime(time);
++ } else {
++ m_reader->skipCurrentElement();
++ }
++ }
++ m_reader->readNext();
++ }
++
++ if (m_reader->hasError())
++ return false;
++ links.append(segmentContainer);
++ return true;
++ }
++
++ bool QGeoRouteXmlParser::parseGeoPoints(const QString &strPoints, QList<QGeoCoordinate> *geoPoints,
++ const QString &elementName)
++ {
++ const QStringList rawPoints = strPoints.split(' ');
++
++ for (const auto &rawPoint : rawPoints) {
++ const QStringList coords = rawPoint.split(',');
++
++ if (coords.length() != 2) {
++ m_reader->raiseError(QStringLiteral("Each of the space separated values of \"%1\" "
++ "is expected to be a comma separated pair of "
++ "coordinates (value was \"%2\")")
++ .arg(elementName).arg(rawPoint));
++ return false;
++ }
++
++ bool ok = false;
++ const QString latString = coords[0];
++ double lat = latString.toDouble(&ok);
++
++ if (!ok) {
++ m_reader->raiseError(QStringLiteral("The latitude portions of \"%1\" are expected to "
++ "have a value convertable to a double (value was "
++ "\"%2\")").arg(elementName).arg(latString));
++ return false;
++ }
++
++ const QString lngString = coords[1];
++ double lng = lngString.toDouble(&ok);
++
++ if (!ok) {
++ m_reader->raiseError(QStringLiteral("The longitude portions of \"%1\" are expected to "
++ "have a value convertable to a double (value was "
++ "\"%2\")").arg(elementName).arg(lngString));
++ return false;
++ }
++
++ QGeoCoordinate geoPoint(lat, lng);
++ geoPoints->append(geoPoint);
++ }
++
++ return true;
++ }
++
++ bool QGeoRouteXmlParser::parseBoundingBox(QGeoRectangle &bounds)
++ {
++ Q_ASSERT(m_reader->isStartElement() && m_reader->name() == QLatin1String("BoundingBox"));
++
++ QGeoCoordinate tl;
++ QGeoCoordinate br;
++
++ m_reader->readNext();
++ while (!(m_reader->tokenType() == QXmlStreamReader::EndElement
++ && m_reader->name() == QLatin1String("BoundingBox")) && !m_reader->hasError()) {
++ if (m_reader->tokenType() == QXmlStreamReader::StartElement) {
++ if (m_reader->name() == QLatin1String("TopLeft")) {
++ QGeoCoordinate coordinates;
++ if (parseCoordinates(coordinates))
++ tl = coordinates;
++ } else if (m_reader->name() == QLatin1String("BottomRight")) {
++ QGeoCoordinate coordinates;
++ if (parseCoordinates(coordinates))
++ br = coordinates;
++ } else {
++ m_reader->skipCurrentElement();
++ }
++ }
++ m_reader->readNext();
++ }
++
++ if (m_reader->hasError())
++ return false;
++
++ if (tl.isValid() && br.isValid()) {
++ bounds = QGeoRectangle(tl, br);
++ return true;
++ }
++
++ return false;
++ }
++
++ bool QGeoRouteXmlParser::parseDynamicSpeedInfo(QGeoDynamicSpeedInfoContainer &speedInfo)
++ {
++ Q_ASSERT(m_reader->isStartElement() && m_reader->name() == QStringLiteral("DynamicSpeedInfo"));
++
++ m_reader->readNext();
++ while (!(m_reader->tokenType() == QXmlStreamReader::EndElement && m_reader->name() == QStringLiteral("DynamicSpeedInfo")) &&
++ !m_reader->hasError()) {
++ if (m_reader->tokenType() == QXmlStreamReader::StartElement) {
++ if (m_reader->name() == QStringLiteral("TrafficSpeed")) {
++ speedInfo.trafficSpeed = m_reader->readElementText().toDouble();
++ } else if (m_reader->name() == QStringLiteral("TrafficTime")) {
++ speedInfo.trafficTime = qRound(m_reader->readElementText().toDouble());
++ } else if (m_reader->name() == QStringLiteral("BaseSpeed")) {
++ speedInfo.baseSpeed = m_reader->readElementText().toDouble();
++ } else if (m_reader->name() == QStringLiteral("BaseTime")) {
++ speedInfo.baseTime = qRound(m_reader->readElementText().toDouble());
++ } else {
++ m_reader->skipCurrentElement();
++ }
++ }
++ m_reader->readNext();
++ }
++
++ return !m_reader->hasError();
++ }
++
++ QT_END_NAMESPACE