C++ QXmlSimpleReader类代码示例

void MainWindow::readDefinitions( QString filename )
{
  ui->statusBar->showMessage( QString("Loading ADIF definitions from \"%1\"").arg(filename) );

  QFile *file = new QFile(filename);
  if( !file->open(QFile::ReadOnly) )
  {
      qDebug() << "Open Definition file failed." << endl;
  }else{
      qDebug() << "Open Definition file success." << endl;
  }
  QXmlSimpleReader xmlReader;
  QXmlInputSource *source = new QXmlInputSource( file );

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

  bool ok = xmlReader.parse(source);

  if( !ok )
  {
      qDebug() << "Parsing Definition file failed." << endl;
  }

  ui->statusBar->showMessage( QString("Loading Country definitions from \"%1\"").arg("DXCCcountries.xml") );

  modes = new QStringList( handler->mode );
  country = new QStringList( );
  subdivisions = new QStringList( );
  bands = QHash <QString, Range>( handler->band );
  //qDebug() << bands["160m"].lower;
}

bool FrmReports::parseXMLFile(const QString itemName, QString& strName, QString& strAuthor, QString& strPixmap, QString& strDescription)
{
    QString strFileName(qApp->translate("dir", strReportsDir) + tr("\\") + itemName + tr(".bdrt"));

    QFile file(strFileName);
    if (!file.exists()) return false;
    if (!file.open(QFile::ReadOnly | QFile::Text)) return false;

    //Just try to parse the xml
    QXmlSimpleReader xmlReader;
    QXmlInputSource *source = new QXmlInputSource(&file);
    if (!xmlReader.parse(source)) {
        file.close();    //exit, but close the file first!
        return false;
    }
    delete source;

    file.close();

    //Initialize the reader
    if (!file.open(QFile::ReadOnly | QFile::Text)) return false;
    QXmlStreamReader xml(&file);

    if (!readProperties(xml, strName, strAuthor, strPixmap, strDescription)) return false;

    file.close();

    return true;
}

void Model::loadWorld( const QString& fileName, bool verbose )
{
	//printf("Loading world file...\n");
    WorldHandler handler( this );
    QXmlSimpleReader reader;
    reader.setContentHandler(&handler);
    reader.setErrorHandler(&handler);
    QFile file(fileName);
	
    if ( !file.open(QFile::ReadOnly | QFile::Text) )
	{
		QString errStr = "failed to open file '";
		errStr.append(fileName);
		errStr.append("'");
		throw KinematicModelException(errStr);
    }
	
    QXmlInputSource xmlInputSource( &file );
    if ( !reader.parse( xmlInputSource ) )
	{
		QString errStr = "failed to create world from file '";
		errStr.append(fileName);
		errStr.append("'");
		throw KinematicModelException(errStr);
    }
	//printf("success!\n");
}

QSharedPointer<HighlightDefinition> Manager::definition(const QString &id)
{
    if (!id.isEmpty() && !m_definitions.contains(id)) {
        QFile definitionFile(id);
        if (!definitionFile.open(QIODevice::ReadOnly | QIODevice::Text))
            return QSharedPointer<HighlightDefinition>();

        QSharedPointer<HighlightDefinition> definition(new HighlightDefinition);
        HighlightDefinitionHandler handler(definition);

        QXmlInputSource source(&definitionFile);
        QXmlSimpleReader reader;
        reader.setContentHandler(&handler);
        m_isBuildingDefinition.insert(id);
        try {
            reader.parse(source);
        } catch (const HighlighterException &e) {
            MessageManager::write(
                        QCoreApplication::translate("GenericHighlighter",
                                                    "Generic highlighter error: ") + e.message(),
                        MessageManager::WithFocus);
            definition.clear();
        }
        m_isBuildingDefinition.remove(id);
        definitionFile.close();

        m_definitions.insert(id, definition);
    }

    return m_definitions.value(id);
}

void SvgCanvas::load_file(QString svg_file_name)
{
	statusBar()->clearMessage();
	
	svg_plot->load(svg_file_name);
	
	QSvgRenderer *renderer=svg_plot->renderer();
	
	if(! renderer->isValid () )
	{
		QFile file(svg_file_name);
		QXmlSimpleReader parser;
		QXmlInputSource source(&file);
		XmlCheckHandler handler(statusBar(), svg_file_name);
		
		file.open(QIODevice::ReadOnly);
		
		parser.setContentHandler(&handler);
		parser.setErrorHandler(&handler);
		
		parser.parse(&source);
		
		file.close();
	}
}

void
TrainingsTageBuch::writeFileCompleted()
{
    printd("TrainingStageBuch::writeFileCompleted()\n");

    QNetworkReply *reply = static_cast<QNetworkReply*>(QObject::sender());

    printd("reply:%s\n", reply->readAll().toStdString().c_str());

    TTBUploadParser handler;
    QXmlInputSource source(reply);

    QXmlSimpleReader reader;
    reader.setContentHandler(&handler);

    bool success = true;
    if(! reader.parse(source)) {
        success = false;
    }

    if(success && handler.error.length() > 0){
        success = false;
    }

    if(success && handler.id.length() == 0 ){
        success = false;
    }

    if (success && reply->error() == QNetworkReply::NoError) {
        notifyWriteComplete(replyName(static_cast<QNetworkReply*>(QObject::sender())), tr("Completed."));
    } else {
        notifyWriteComplete( replyName(static_cast<QNetworkReply*>(QObject::sender())), tr("Error - Upload failed."));
    }
}

bool Filters::load(const QString& filename)
{
  // clear existing 
  clear();

  // load filters
  m_file = filename;

  // create XML content handler
  LoadXmlContentHandler handler(*this, m_types);

  // create a file object on the file
  QFile xmlFile(filename);

  // create an XmlInputSource on the file
  QXmlInputSource source(&xmlFile);
  
  // create an XML parser
  QXmlSimpleReader reader;

  // set the content handler
  reader.setContentHandler(&handler);

  // parse the file
  return reader.parse(source);
}

void RemoteController::processReadData(const QByteArray &data) {
	QXmlSimpleReader reader;
	RemoteController::XmlHandler *xmlHandler = new RemoteController::XmlHandler();

	reader.setContentHandler(xmlHandler);
	QXmlInputSource buffer;
	buffer.setData(data);
	reader.parse(&buffer);

	isStarted = xmlHandler->my_started;
	isGameOver = xmlHandler->my_gameover;

	if (isStarted == 1) {
		myLeftBtn->setEnabled(true);
		myRightBtn->setEnabled(true);
		myStartBtn->setEnabled(false);
	}
	if (isGameOver == 1) {
		myLeftBtn->setEnabled(false);
		myRightBtn->setEnabled(false);
		--myLostBalls;
		if (myLostBalls > 0) {
			myLostBallsLbl->setText(QString::number(myLostBalls));
			myStartBtn->setEnabled(true);
		} else {
			myLostBallsLbl->setText("The game is over :(");
			myStartBtn->setEnabled(false);
		}
	}
}

void cbSimulator::setDefaultGrid(void)
{
	QXmlInputSource *source;

    source = new QXmlInputSource;
        source->setData(QByteArray(GRID));

        QXmlSimpleReader xmlParser;

	cbGridHandler *gridHandler = new cbGridHandler;
	xmlParser.setContentHandler(gridHandler);

    cbGrid *grid;
	if(xmlParser.parse(*source))
        grid = gridHandler->parsedGrid();
	else {
        cerr << "Error parsing DEFAULT grid\n";
        gui->appendMessage(QString("Error parsing DEFAULT grid"), true);
		assert(0);
	}

    setGrid(grid);
	delete gridHandler;
	delete source;

	//rebuild graph
	if(lab!=0) {
        buildGraph();
        setDistMaxFromGridToTarget();
	}

    // update parameters
    //param->gridFilename = "";
}

bool ZkbConfig::load(const QString& file, Keymap& keymap, const QString& prefix) {
    bool ret;
    QFile *f = new QFile(path+"/"+file);
    QFileInfo fi(*f);

    /* Try */
    if ( !fi.exists() && !path.contains( QPEApplication::qpeDir()) ) {
        delete f;
        f  = new QFile( QPEApplication::qpeDir() + "share/zkb/" + file );
        fi = QFileInfo( *f );
    }

    odebug << "start loading file=" << file << "\n" << oendl;
    if (includedFiles.find(fi.absFilePath()) != includedFiles.end()) {
        return false;
    }

    includedFiles.insert(fi.absFilePath(), 1);
    QXmlInputSource is(*f);
    QXmlSimpleReader reader;
    ZkbHandler h(*this, keymap, prefix);

    reader.setContentHandler(&h);
    reader.setErrorHandler(this);
    ret = reader.parse(is);
    includedFiles.remove(fi.absFilePath());

    odebug << "end loading file=" << file << ": status=" << err << oendl;
    delete f;
    return ret;
}

void FRXMLCharDataReader::parseSingleImageFile(const std::string fileName, const std::string resultFileName, GrayImage<> *pImage, std::vector<ImageChar> &imageCharVec, const int imageId /*= 0*/) const
{
	// create the finereader xml output handler object need for parsing the files
	FineReaderXMLOutputHandler *pXMLHandler = new FineReaderXMLOutputHandler();
	// create simple reader and set the content/error handler
    QXmlSimpleReader reader;
    reader.setContentHandler(pXMLHandler);
    reader.setErrorHandler(pXMLHandler);

	// create QFile object
    QFile file( QString::fromStdString(resultFileName) );
    if (!file.open(QFile::ReadOnly | QFile::Text)) {
     	throw Exception("Error openening xml-file in FRXMLCharDataReader::parseXMLFiles!");
     }
     // create xml input source from file object
     QXmlInputSource xmlInputSource(&file);
     // parse the file using the simple reader
     reader.parse(xmlInputSource);
     std::cout << "Successfully parsed xml data of file " << resultFileName << std::endl;
 	// store results
     SimpleFineReaderXMLData* pData = pXMLHandler->getFineReaderData();
//     imageCharVec.clear();
     for (int j=0; j<pData->parsedBBoxes.size(); ++j) {
     	ImageChar imChar(pData->parsedBBoxes[j], pImage, imageId, imageCharVec.size());
     	imChar.text = pData->parsedChars[j];
     	imChar.suspicious = pData->isSuspicious[j];

     	imageCharVec.push_back(imChar);
     } // end for j
     pXMLHandler->clearData();
     delete pXMLHandler;

     return;
} // end parseSingleImageFile

void BDHServerController::loadConfiguration()
{
    QFile file;

    //! Set XML dir
    file.setFileName(QString("./hmi.xml"));

    //! Open file
    if (!file.open(QFile::ReadOnly | QFile::Text))
    {
        qDebug() << "Not hmi.xml file present and can't configure. \n CLOSING...";
        exit(-1);
    }

    //! Set XML reader
    QXmlSimpleReader reader;
    reader.setContentHandler(m_configurationLoader);
    reader.setErrorHandler(m_configurationLoader);
    QXmlInputSource xmlInputSource(&file);

    //! Parse hmi.xml file for proyect configuration
    if (!reader.parse(xmlInputSource))
    {
        //!Show error parsing hmi.xml
        qDebug() << QString("There was an error while loading the configuration: %1. \n CLOSING...").arg(m_configurationLoader->errorString());
        exit(-1);
    }

}

bool KDReports::Report::loadFromXML( QIODevice* iodevice, ErrorDetails* details )
{
    QDomDocument doc;
    // Read document from the QIODevice, check for errors

    // We need to be able to see the space in <text> </text>, this is why
    // we activate the "report-whitespace-only-CharData" feature.
    // Unfortunately this leads to lots of whitespace text nodes in between real
    // elements in the rest of the document, watch out for that.
    if (iodevice->isOpen())
        iodevice->reset(); //need to do that to allow consecutive calls of loadFromXML()
    QXmlInputSource source( iodevice );
    QXmlSimpleReader reader;
    reader.setFeature( QLatin1String( "http://xml.org/sax/features/namespaces" ), false );
    reader.setFeature( QLatin1String( "http://xml.org/sax/features/namespace-prefixes" ), true );
    reader.setFeature( QLatin1String( "http://trolltech.com/xml/features/report-whitespace-only-CharData" ), true );

    QString errorMsg;
    int errorLine = 0, errorColumn = 0;
    bool ret = doc.setContent( &source, &reader, &errorMsg, &errorLine, &errorColumn );
    if( !ret ) {
        if ( details ) {
            details->setLine( errorLine );
            details->setColumn( errorColumn );
            details->setDriverMessage( errorMsg );
        }
        else
            qWarning( "Malformed XML read in KDReports::Report::loadFromXML(): error message = %s, error line = %d, error column = %d", qPrintable( errorMsg ), errorLine, errorColumn );
        return false;
    }
    return loadFromXML( doc, details );
}

Scenegraph* ObjectXMLReader::readObjectXMLFile(string filename, GLint objectColorLocation, GLint modelviewLocation, glm::mat4& modelview)
{
    //Create a file handler and tell it were the color and modelview
    ObjectXMLFileHandler handler;
    handler.setObjectColorLocation(objectColorLocation);
    handler.setModelviewLocation(modelviewLocation);
    //pass the modelview matrix to the handler (the camera position)
    handler.setModelview(modelview);
    //create a simple reader
    QXmlSimpleReader reader;
    //create a Qfile
    QFile xmlFile(QString::fromStdString(filename));
    //specify the source
    QXmlInputSource source(&xmlFile);

    //declare a new scenegraph
    Scenegraph* scene;
    //set the content handler
    reader.setContentHandler(&handler);
    //parse
    bool answer = reader.parse(source);
    //if successful, set the scene
    if (answer)
    {
        scene = handler.getScene();
    }
    //otherwise, print an error
    else
        printf("Parsing unsuccessful because %s\n",handler.errorString().toLatin1().constData());
    return scene;
}

const QString PatternParser::parseSimplePattern(const QString& pattern,
        int cdno, const int nooftracks,
        const QString& artist, const QString& title,
        const QString& date, const QString& genre, const QString& suffix,
        bool fat32compatible) {

  SaxHandler handler;
  handler.setCDNo(cdno);
  handler.setNoOfTracks(nooftracks);
  handler.setArtist(artist);
  handler.setTitle(title);
  handler.setDate(date);
  handler.setGenre(genre);
  handler.setSuffix(suffix);
  handler.setFAT32Compatible(fat32compatible);
  handler.setReplaceSpacesWithUnderscores(false);
  handler.set2DigitsTrackNum(false);

  QXmlInputSource inputSource;
  inputSource.setData("<simplepattern>"+p_xmlize_pattern(pattern)+"</simplepattern>");
  QXmlSimpleReader reader;
  reader.setContentHandler(&handler);
  reader.setErrorHandler(&handler);
  reader.parse(inputSource);

  return handler.text();

}