void XmlUtil::readServerConfig ( const QString& xml, ServerConfig& conf )
{
QXmlStreamReader reader ( xml );
while ( !reader.atEnd() ) {
if ( reader.readNext() == QXmlStreamReader::StartElement )
break;
}
if ( reader.name() != CONFIG_ROOT_TAG )
throw InvalidXmlException("No config root tag found.",
reader.lineNumber(), reader.columnNumber(), reader.characterOffset());
while ( !reader.atEnd() ) {
if ( reader.readNext() == QXmlStreamReader::StartElement ) {
if ( reader.name() == "port" ) {
bool ok;
conf.port = reader.readElementText().toInt(&ok);
if ( !ok || conf.port > (1 << 16 - 1) )
throw InvalidXmlException("Invalid server port specified.",
reader.lineNumber(), reader.columnNumber(), reader.characterOffset());
} else if ( reader.name() == "db" ) {
conf.db_path = reader.readElementText();
} else if ( reader.name() == "stage_file" ) {
conf.stage_files.push_back(reader.readElementText());
} else {
//barf?
}
}
}
if ( reader.hasError() )
throw IllFormedXmlException(reader.errorString(), reader);
}
bool Pastebin::parsePasteList(QXmlStreamReader& reader, QList<PasteListing> *pasteList) {
while(!reader.atEnd()) {
QXmlStreamReader::TokenType token = reader.readNext();
if(token == QXmlStreamReader::StartDocument) {
qDebug() << "StartDocument";
continue;
}
else if(token == QXmlStreamReader::StartElement) {
if(reader.name() == "paste") {
parsePasteElement(reader, pasteList);
}
}
else if(token == QXmlStreamReader::EndDocument) {
qDebug() << "EndDocument";
continue;
}
}
qDebug() << "Parsed" << pasteList->size() << "paste elements";
if(reader.hasError()) {
qWarning() << "Parse error:" << reader.errorString();
return false;
}
else {
return true;
}
}
//Get config from xml file
void queryFromConfigStream(QXmlStreamReader& reader)
{
xgxPerfConfigParams* inParams;
QString currVal1, currVal2, currName;
while (!reader.atEnd())
{
reader.readNext();
if (reader.isStartElement()) {
if(reader.name() == "object")
{
currVal1 = reader.attributes().value("type").toString();
//qDebug() << "object type = " << currVal1;
inParams = new xgxPerfConfigParams;
xgxPerfConfigParamsList << inParams;
}
else if(reader.name() == "param")
{
currName = reader.attributes().value("name").toString();
currVal2 = reader.attributes().value("value").toString();
//qDebug() << "param name = " << currName << " ,value = " << currVal2 ;
if(currName == "iconName") inParams->iconName = currVal2;
else if(currName == "iconLabel") inParams->iconLabel = currVal2;
else if(currName == "appName") inParams->appName = currVal2;
else if(currName == "appParameters") inParams->appParameters = currVal2;
else if(currName == "appParameters2") inParams->appParameters2 = currVal2;
}
}
}
if (reader.hasError()) {
qDebug() << " Error in HTML file formation" << reader.errorString();
}
}
bool OsmAnd::MapStyle_P::parseMetadata( QXmlStreamReader& xmlReader )
{
while (!xmlReader.atEnd() && !xmlReader.hasError())
{
xmlReader.readNext();
const auto tagName = xmlReader.name();
if (xmlReader.isStartElement())
{
if (tagName == QLatin1String("renderingStyle"))
{
_title = xmlReader.attributes().value(QLatin1String("name")).toString();
auto attrDepends = xmlReader.attributes().value(QLatin1String("depends"));
if(!attrDepends.isNull())
_parentName = attrDepends.toString();
}
}
else if (xmlReader.isEndElement())
{
}
}
if(xmlReader.hasError())
{
std::cerr << qPrintable(xmlReader.errorString()) << "(" << xmlReader.lineNumber() << ", " << xmlReader.columnNumber() << ")" << std::endl;
return false;
}
return true;
}
QString composeMessage( const QXmlStreamReader& xml ) {
QString errorstr( xml.errorString() );
errorstr += " at line " + QString::number(xml.lineNumber());
errorstr += " (column " + QString::number(xml.columnNumber());
errorstr += ")";
return errorstr;
}
QVariantList DeliciousApi::ParseDownloadReply (const QByteArray& content)
{
QVariantList list;
QVariantMap record;
QXmlStreamReader xml (content);
while (!xml.atEnd () &&
!xml.hasError ())
{
QXmlStreamReader::TokenType token = xml.readNext ();
if (token == QXmlStreamReader::StartDocument)
continue;
if (token == QXmlStreamReader::StartElement &&
xml.name() == "post")
{
record ["URL"] = xml.attributes ().value ("href").toString ();
record ["Title"] = xml.attributes ().value ("description").toString ();;
record ["Tags"] = xml.attributes ().value ("tag").toString ();
list << record;
}
}
qWarning () << Q_FUNC_INFO
<< "Parsing finished with error"
<< xml.errorString ();
return list;
}
void Gitarre::ReadSavedRepos ()
{
QFile saveFile (UserDataDir.absolutePath() + "/repos");
saveFile.open (QIODevice::ReadWrite | QIODevice::Text);
if (saveFile.isOpen())
{
QXmlStreamReader reader (&saveFile);
while (!reader.atEnd()) {
int token = reader.readNext();
if (token == QXmlStreamReader::Invalid)
std::cout << reader.errorString().toStdString() << "\n";
if (token == QXmlStreamReader::StartElement)
{
QString name = reader.name ().toString();
if (name == "repository")
{
QXmlStreamAttributes attr = reader.attributes();
QString path = attr.value ("path").toString();
if (!path.isEmpty())
AddRepo (path);
}
}
}
saveFile.close();
}
}
StationsList ParserHafasXml::internalParseStationsByName(const QString &data) const
{
StationsList result;
QXmlStreamReader xml;
xml.addData(data);
while (!xml.atEnd()) {
xml.readNext();
if (xml.isStartElement()) {
if (xml.name() == "MLc")
{
Station item;
item.id = xml.attributes().value("i").toString();
item.name = xml.attributes().value("n").toString();
item.type = xml.attributes().value("t").toString();
item.latitude = xml.attributes().value("y").toString().toInt();
item.longitude = xml.attributes().value("x").toString().toInt();
QString miscInfo = xml.attributes().value("dist").toString();
if (!miscInfo.isEmpty()) {
item.miscInfo = miscInfo + "m";
}
result << item;
}
}
}
if (xml.error() && xml.error() != QXmlStreamReader::PrematureEndOfDocumentError) {
qWarning() << "XML ERROR:" << xml.lineNumber() << ": " << xml.errorString();
}
return result;
}
/*!
* Loads AWS endpoint data from \a xml.
*
* This function parses AWS endpoint data in XML format. The XML data is
* expected to match the same format as the file provided by Amazon at
* http://aws-sdk-configurations.amazonwebservices.com/endpoints.xml
*
* If \e any data has been loaded previously, this function will return
* immediately with no parsing performed.
*/
void AwsEndpointPrivate::loadEndpointData(QXmlStreamReader &xml)
{
QMutexLocker locker(&mutex);
if (!hosts.empty()) {
return; // Already loaded.
}
// Parse the XML data.
while (xml.readNextStartElement()) {
if (xml.name() == QLatin1String("Regions")) {
parseRegions(xml);
} else if (xml.name() == QLatin1String("Services")) {
parseServices(xml);
} else if (xml.name() != QLatin1String("XML")) {
qDebug() << "ignoring" << xml.name();
}
}
if (xml.hasError()) {
qWarning() << "AwsEndpoint:" << xml.errorString();
}
Q_ASSERT(!xml.hasError());
Q_ASSERT(!hosts.isEmpty());
Q_ASSERT(!regions.isEmpty());
Q_ASSERT(!services.isEmpty());
}
void xmlHasError(QXmlStreamReader &xml,QString filename){
QString ERROR=QObject::tr("Error in file:%4\n%1\nLine %2, column %3")
.arg(xml.errorString())
.arg(xml.lineNumber())
.arg(xml.columnNumber())
.arg(filename);
QMessageBox::information(0, QString(QObject::tr("Error")), ERROR, QMessageBox::Ok);
}
bool OsmAnd::OnlineTileSources_P::deserializeFrom(QXmlStreamReader& xmlReader)
{
QHash< QString, std::shared_ptr<const Source> > collection;
while(!xmlReader.atEnd() && !xmlReader.hasError())
{
xmlReader.readNext();
if (!xmlReader.isStartElement())
continue;
const auto tagName = xmlReader.name();
if (tagName == QLatin1String("tile_source"))
{
// Original format of the tile sources, used in the Android application
if (xmlReader.attributes().hasAttribute("rule"))
continue; // Rules are not supported
const auto name = xmlReader.attributes().value(QLatin1String("name")).toString();
if (collection.contains(name))
{
LogPrintf(LogSeverityLevel::Warning, "Ignored duplicate online tile source with name '%s'", qPrintable(name));
continue;
}
const auto originalUrlTemplate = xmlReader.attributes().value(QLatin1String("url_template")).toString();
auto urlPattern = originalUrlTemplate;
urlPattern = urlPattern.replace(QLatin1String("{0}"), QLatin1String("${osm_zoom}"));
urlPattern = urlPattern.replace(QLatin1String("{1}"), QLatin1String("${osm_x}"));
urlPattern = urlPattern.replace(QLatin1String("{2}"), QLatin1String("${osm_y}"));
const auto minZoom = static_cast<ZoomLevel>(xmlReader.attributes().value(QLatin1String("min_zoom")).toUInt());
const auto maxZoom = static_cast<ZoomLevel>(xmlReader.attributes().value(QLatin1String("max_zoom")).toUInt());
const auto tileSize = xmlReader.attributes().value(QLatin1String("tile_size")).toUInt();
std::shared_ptr<Source> newSource(new Source(name));
newSource->urlPattern = urlPattern;
newSource->minZoom = minZoom;
newSource->maxZoom = maxZoom;
newSource->maxConcurrentDownloads = 1;
newSource->tileSize = tileSize;
newSource->alphaChannelData = AlphaChannelData::Undefined;
collection.insert(name, newSource);
}
else if (tagName == QLatin1String("tileSource"))
{
//TODO: parse new format, but create it first :)
}
}
if (xmlReader.hasError())
{
LogPrintf(LogSeverityLevel::Warning, "XML error: %s (%d, %d)", qPrintable(xmlReader.errorString()), xmlReader.lineNumber(), xmlReader.columnNumber());
return false;
}
_collection = collection;
return true;
}
static bool parseTemplateXml(QXmlStreamReader &reader, TemplateInfo *info)
{
const QString locale = languageSetting();
static const QLatin1String tag_template("template");
static const QLatin1String tag_displayName("displayname");
static const QLatin1String tag_description("description");
static const QLatin1String attribute_featuresRequired("featuresRequired");
static const QLatin1String attribute_openEditor("openeditor");
static const QLatin1String attribute_priority("priority");
static const QLatin1String attribute_viewerdir("viewerdir");
static const QLatin1String attribute_viewerclassname("viewerclassname");
static const QLatin1String attribute_qrcdeployment("qrcdeployment");
static const QLatin1String attribute_stubversionminor("stubversionminor");
while (!reader.atEnd() && !reader.hasError()) {
reader.readNext();
if (reader.tokenType() != QXmlStreamReader::StartElement)
continue;
if (reader.name() == tag_template) {
info->openFile = reader.attributes().value(attribute_openEditor).toString();
if (reader.attributes().hasAttribute(attribute_priority))
info->priority = reader.attributes().value(attribute_priority).toString();
if (reader.attributes().hasAttribute(attribute_featuresRequired))
info->featuresRequired = reader.attributes().value(attribute_featuresRequired).toString();
if (reader.attributes().hasAttribute(attribute_viewerdir))
info->viewerDir = reader.attributes().value(attribute_viewerdir).toString();
if (reader.attributes().hasAttribute(attribute_viewerclassname))
info->viewerClassName = reader.attributes().value(attribute_viewerclassname).toString();
if (reader.attributes().hasAttribute(attribute_qrcdeployment))
info->qrcDeployment = reader.attributes().value(attribute_qrcdeployment).toString();
if (reader.attributes().hasAttribute(attribute_stubversionminor))
info->stubVersionMinor = reader.attributes().value(attribute_stubversionminor).toString().toInt();
} else if (reader.name() == tag_displayName) {
if (!assignLanguageElementText(reader, locale, &info->displayName))
continue;
} else if (reader.name() == tag_description) {
if (!assignLanguageElementText(reader, locale, &info->description))
continue;
}
}
if (reader.hasError()) {
qWarning() << reader.errorString();
return false;
}
return true;
}
// in future - read/write project file from xml
bool dataAnalysis::readProject(const QString &fileName)
{
bool rval = false;
// an XML stream reader
QXmlStreamReader reader;
// try to open the file and check for errors
QFile file(fileName);
if (!file.open(QFile::ReadOnly | QFile::Text)) {
std::cerr << "Error: Cannot read file " << qPrintable(fileName)
<< ": " << qPrintable(file.errorString())
<< std::endl;
rval = false;
}
else {
// set the device
reader.setDevice(&file);
// read the first element
reader.readNext();
// go through the file
while (!reader.atEnd()) {
if (reader.isStartElement()) {
if ((reader.name() == "p502project") && (reader.attributes().value("version").toString() == "1.0")) {
this->readElement(&reader);
}
else { reader.raiseError(QObject::tr("Not a p502project file with version 1.0 - instead: %1").arg(reader.attributes().value("version").toString())); }
}
else { reader.readNext(); }
}
// close the file and check for errors
file.close();
if (reader.hasError()) {
std::cerr << "Error: Failed to parse file "
<< qPrintable(fileName) << ": "
<< reader.error() << " - "
<< qPrintable(reader.errorString()) << std::endl;
rval = false;
}
else if (file.error() != QFile::NoError) {
std::cerr << "Error: Cannot read file " << qPrintable(fileName)
<< ": " << qPrintable(file.errorString())
<< std::endl;
rval = false;
}
else { rval = true; }
}
return(rval);
}
QFile::FileError QLCFixtureDef::loadXML(const QString& fileName)
{
QFile::FileError error = QFile::NoError;
if (fileName.isEmpty() == true)
return QFile::OpenError;
QXmlStreamReader *doc = QLCFile::getXMLReader(fileName);
if (doc == NULL || doc->device() == NULL || doc->hasError())
{
qWarning() << Q_FUNC_INFO << "Unable to read from" << fileName;
return QFile::ReadError;
}
while (!doc->atEnd())
{
if (doc->readNext() == QXmlStreamReader::DTD)
break;
}
if (doc->hasError())
{
QLCFile::releaseXMLReader(doc);
return QFile::ResourceError;
}
if (doc->dtdName() == KXMLQLCFixtureDefDocument)
{
// qDebug() << Q_FUNC_INFO << "Loading " << fileName;
if (loadXML(*doc) == true)
error = QFile::NoError;
else
{
qWarning() << fileName << QString("%1\nLine %2, column %3")
.arg(doc->errorString())
.arg(doc->lineNumber())
.arg(doc->columnNumber());
error = QFile::ReadError;
}
}
else
{
error = QFile::ReadError;
qWarning() << Q_FUNC_INFO << fileName
<< "is not a fixture definition file";
}
QLCFile::releaseXMLReader(doc);
return error;
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
QFile file("../myXmlStream/my.xml");
if (!file.open(QFile::ReadOnly | QFile::Text))
{
qDebug()<<"Error: cannot open file";
return 1;
}
QXmlStreamReader reader;
// 设置文件，这时会将流设置为初始状态
reader.setDevice(&file);
// 如果没有读到文档结尾，而且没有出现错误
while (!reader.atEnd()) {
// 读取下一个记号，它返回记号的类型
QXmlStreamReader::TokenType type = reader.readNext();
// 下面便根据记号的类型来进行不同的输出
if (type == QXmlStreamReader::StartDocument)
qDebug() << reader.documentEncoding() << reader.documentVersion();
if (type == QXmlStreamReader::StartElement) {
qDebug() << "<" << reader.name() << ">";
if (reader.attributes().hasAttribute("id"))
qDebug() << reader.attributes().value("id");
}
if (type == QXmlStreamReader::EndElement)
qDebug() << "</" << reader.name() << ">";
if (type == QXmlStreamReader::Characters && !reader.isWhitespace())
qDebug() << reader.text();
}
// 如果读取过程中出现错误，那么输出错误信息
if (reader.hasError()) {
qDebug() << "error: " << reader.errorString();
}
file.close();
return a.exec();
}
void MetaInfoParser::errorHandling(QXmlStreamReader &reader, QFile &file)
{
if (!reader.hasError())
return;
qDebug() << QString("Error at %1, %2:%3: %4")
.arg(file.fileName())
.arg(reader.lineNumber())
.arg(reader.columnNumber())
.arg(reader.errorString());
file.reset();
QString fileString = file.readAll();
QString snippetString;
int lineCount = 0;
int position = reader.characterOffset();
while (position >= 0)
{
if (fileString[position] == '\n') {
if (lineCount > 3)
break;
lineCount++;
}
snippetString.prepend(fileString[position]);
position--;
}
lineCount = 0;
position = reader.characterOffset();
while (position >= 0)
{
position++;
if (fileString[position] == '\n') {
if (lineCount > 1)
break;
lineCount++;
}
snippetString.append(fileString[position]);
}
qDebug() << snippetString;
}
//=============================================================================
bool GoogleEngine::parseWeather(WeatherInfo &aInfo)
{
QString aXmlPath;
aXmlPath = "chengdu.xml";
QFile file(aXmlPath);
//QFileInfo info;
//info.setFile(aXmlPath);
//bool is = info.exists();
file.open(QIODevice::ReadOnly | QIODevice::Text );
int iForecastDay = 0;
QXmlStreamReader xml;
xml.setDevice(&file);
while(!xml.atEnd()) {
xml.readNext();
//QString element = xml.name().toString();
if(xml.isStartElement()) {
//bool l = xml.attributes().hasAttribute("data");
if (parseForecastInformation(xml, aInfo)) {
continue;
}
if(parseCurrentCondition(xml, aInfo)) {
continue;
}
if (parseForecastCondition(xml, aInfo, iForecastDay)) {
iForecastDay++;
continue;
}
} else if (xml.isCharacters()) {
} else if (xml.isEndElement()) {
}
}
if (xml.hasError()) {
qDebug(xml.errorString().toLatin1());
}
file.close();
aInfo.mForecastDay = iForecastDay;
return true;
}
bool HbThemeSystemEffect::checkStartElement(QXmlStreamReader &xml,
const QLatin1String &startElement)
{
xml.readNext();
while (!xml.isStartElement() && !xml.atEnd()) {
xml.readNext();
}
bool success = xml.isStartElement();
if (success && xml.name() != startElement) {
success = false;
} else if (xml.error()) {
qWarning() << "HbThemeSystemEffect::checkStartElement:"
<< " Error when parsing system effect configuration : " << xml.errorString();
} else if (!success && !xml.name().isEmpty()) {
qWarning() << "HbThemeSystemEffect::checkStartElement: "
<< "Error when parsing system effect configuration with element: " << xml.name();
}
return success;
}
bool DeliciousApi::ParseAuthReply (const QByteArray& content)
{
QXmlStreamReader xml (content);
while (!xml.atEnd () &&
!xml.hasError ())
{
QXmlStreamReader::TokenType token = xml.readNext ();
if (token == QXmlStreamReader::StartDocument)
continue;
if (token == QXmlStreamReader::StartElement &&
xml.name() == "update" &&
xml.attributes ().hasAttribute ("time"))
return true;
}
qWarning () << Q_FUNC_INFO
<< "Parsing finished with error"
<< xml.errorString ();
return false;
}
QStringList MainWindow::getFromXML(QString file, QString token, int cant)
{
int cont = 0;
QStringList valtokens;
QFile archivo(file);
if (archivo.open(QFile::ReadOnly | QFile::Text))
{
QXmlStreamReader reader;
reader.setDevice(&archivo);
while (!reader.atEnd())
{
reader.readNext();
if (reader.isStartElement())
{
QString name = reader.name().toString();
//QTextStream(stdout)<<name<<endl;
if( name==token ){
if(cont >= cant) break;
valtokens << reader.readElementText();
cont++;
}
}
}
if (reader.hasError())
{
writeText(reader.errorString(), msg_alert);
}
}else{
writeText("^ [Error al abrir el archivo xml: "+file+"]", msg_alert);
}
archivo.close();
return valtokens;
}
void PhoenixLibrary::loadXml(QString file_path)
{
QResource resource(file_path);
QFile in_file(resource.absoluteFilePath());
if (in_file.open(QIODevice::ReadOnly | QIODevice::Text)) {
QXmlStreamReader reader;
reader.setDevice(&in_file);
while (!reader.isEndDocument()) {
reader.readNext();
QString element = reader.name().toString();
qCDebug(phxLibrary) << element;
if (element == "name")
qCDebug(phxLibrary) << reader.readElementText();
}
if (reader.hasError()) {
qCDebug(phxLibrary) << reader.errorString();
}
in_file.close();
}
else
qCDebug(phxLibrary) << file_path << " was not opened";
}
QString ScutRSS::parseXml(const QString &data){
QString titleString;
QString currentTag;
QString dateString;
QString linkString;
QString description;
QString html = "<html><h1>Scutum RSS</h1>";
QXmlStreamReader xml;
xml.addData(data);
while (!xml.atEnd()) {
xml.readNext();
if (xml.isStartElement()) {
if (xml.name() == "item"){
if (titleString!=""){
//feed = new QTreeWidgetItem;
//feed->setText(0, titleString);
//feed->setText(2, linkString);
//ui->treeWidget->addTopLevelItem(feed);
//qDebug() << __PRETTY_FUNCTION__<< " title: " << titleString << " linkString: " << linkString;
}
description.clear();
linkString.clear();
titleString.clear();
dateString.clear();
}
currentTag = xml.name().toString();
//qDebug() << __PRETTY_FUNCTION__<< " current tag: " << currentTag;
} else if (xml.isEndElement()) {
if (xml.name() == "item") {
//qDebug() << __PRETTY_FUNCTION__<< " title: " << titleString << " linkString: " << linkString;
html = html + "<p><h2><a href=\"" + linkString +"\">" + titleString + "</a></h2></p>";
html = html + "<p><h3>" + description + "<h3></p>";
//QTreeWidgetItem *item = new QTreeWidgetItem(feed);
//item->setText(0, titleString);
//item->setText(1, dateString);
//item->setText(2, linkString);
//ui->treeWidget->addTopLevelItem(item);
titleString.clear();
linkString.clear();
dateString.clear();
}
} else if (xml.isCharacters() && !xml.isWhitespace()) {
if (currentTag == "channel"){
qDebug() << __PRETTY_FUNCTION__<< " channel: " << currentTag;
//titleString += xml.text().toString();
}
if (currentTag == "description"){
qDebug() << __PRETTY_FUNCTION__<< " description: " << xml.text();
description += xml.text().toString();
}
else if (currentTag == "title"){
//qDebug() << __PRETTY_FUNCTION__<< " current tag: " << currentTag;
titleString += xml.text().toString();
}
else if (currentTag == "link"){
linkString += xml.text().toString();
//qDebug() << __PRETTY_FUNCTION__<< " current link: " << currentTag;
}
else if (currentTag == "pubDate"){
dateString += xml.text().toString();
//qDebug() << __PRETTY_FUNCTION__<< " current date: " << currentTag;
}
}
}
if (xml.error() && xml.error() != QXmlStreamReader::PrematureEndOfDocumentError) {
qWarning() << "XML ERROR:" << xml.lineNumber() << ": " << xml.errorString();
//http.abort();
}
html = html + "</html>";
return html;
} // QString ScutRSS::parseXml(const QString &data);
bool OsmAnd::MapStylesPresetsCollection_P::deserializeFrom(QXmlStreamReader& xmlReader)
{
QList< std::shared_ptr<MapStylePreset> > order;
QHash< QString, QHash< QString, std::shared_ptr<MapStylePreset> > > collection;
std::shared_ptr<MapStylePreset> mapStylePreset;
while(!xmlReader.atEnd() && !xmlReader.hasError())
{
xmlReader.readNext();
const auto tagName = xmlReader.name();
if (xmlReader.isStartElement())
{
if (tagName == QLatin1String("mapStylePreset"))
{
const auto type_ = xmlReader.attributes().value(QLatin1String("type")).toString();
auto type = MapStylePreset::Type::Custom;
if (!type_.isEmpty())
{
if (type_ == QLatin1String("general"))
type = MapStylePreset::Type::General;
else if (type_ == QLatin1String("pedestrian"))
type = MapStylePreset::Type::Pedestrian;
else if (type_ == QLatin1String("bicycle"))
type = MapStylePreset::Type::Bicycle;
else if (type_ == QLatin1String("car"))
type = MapStylePreset::Type::Car;
else if (type_ != QLatin1String("custom"))
{
LogPrintf(LogSeverityLevel::Warning, "Ignored map style preset with unknown type '%s'", qPrintable(type_));
continue;
}
}
auto name = xmlReader.attributes().value(QLatin1String("name")).toString();
if (type != MapStylePreset::Type::Custom && name.isEmpty())
name = QLatin1String("type_") + type_;
auto styleName = xmlReader.attributes().value(QLatin1String("style")).toString();
if (type == MapStylePreset::Type::Custom && name.isEmpty())
{
LogPrintf(LogSeverityLevel::Warning, "Ignored map style preset with empty name and custom type");
continue;
}
if (styleName.isEmpty())
{
LogPrintf(LogSeverityLevel::Warning, "Ignored orphaned map style preset with name '%s' and type '%s'", qPrintable(name), qPrintable(type_));
continue;
}
mapStylePreset.reset(new MapStylePreset(type, name, styleName));
}
else if (tagName == QLatin1String("attribute"))
{
if (!mapStylePreset)
continue;
const auto name = xmlReader.attributes().value(QLatin1String("name")).toString();
const auto value = xmlReader.attributes().value(QLatin1String("value")).toString();
mapStylePreset->attributes.insert(name, value);
}
}
else if (xmlReader.isEndElement())
{
if (tagName == QLatin1String("mapStylePreset"))
{
auto& collectionForStyle = collection[mapStylePreset->styleName];
if (!collectionForStyle.contains(mapStylePreset->name))
{
collectionForStyle.insert(mapStylePreset->name, mapStylePreset);
order.push_back(mapStylePreset);
}
else
LogPrintf(LogSeverityLevel::Warning, "Ignored duplicate map style preset with name '%s'", qPrintable(mapStylePreset->name));
mapStylePreset.reset();
}
}
}
if (xmlReader.hasError())
{
LogPrintf(LogSeverityLevel::Warning, "XML error: %s (%d, %d)", qPrintable(xmlReader.errorString()), xmlReader.lineNumber(), xmlReader.columnNumber());
return false;
}
_order = order;
_collection = collection;
return true;
}
/**
* Updates the widget from the conf netperf node
* @param elem
*/
void NMGNetperfXMLInterpret::updateWidgetFromXMLNodeConfNetperf ( const QString & elem )
{
// widget->chkStartTime->setCheckded ( false );
widget->txtSourcePort->setValue ( 12865 );
widget->chkSms->setChecked ( false );
widget->txtSms->setText ( "" );
widget->chkSss->setChecked ( false );
widget->txtSss->setText ( "" );
widget->chkRms->setChecked ( false );
widget->txtRms->setText ( "" );
widget->chkRss->setChecked ( false );
widget->txtRss->setText ( "" );
QXmlStreamReader xml ( elem );
while ( !xml.atEnd() )
{
xml.readNext();
if ( xml.isStartElement() )
{
if ( xml.name() == TAG_PORT )
widget->txtSourcePort->setValue ( xml.readElementText().toInt() );
/*else if ( xml.name() == TAG_START )
{
widget->chkStartTime->setChecked ( true );
QString startTime = xml.readElementText();
if ( startTime.right ( 3 ) == "GMT" )
widget->comboGMTOrLocalTime->setItemText ( 1, "GMT" );
else widget->comboGMTOrLocalTime->setItemText ( 0, "Local" );
QString hour = startTime.left ( 2 );
QString minutes = startTime.mid ( 3, 2 );
QString seconds = startTime.mid ( 6, 2 );
widget->timeStartTime->setTime ( QTime ( hour.toInt(), minutes.toInt(), seconds.toInt() ) );
}*/
else if ( xml.name() == TAG_DURATION )
{
bool secs = ( xml.attributes().value ( ATTR_TYPE ).toString() == "seconds" );
widget->txtTestDuration->setValue ( xml.readElementText().toInt() );
widget->radSeconds->setChecked ( secs );
widget->radBytes->setChecked ( !secs );
}
else if ( xml.name() == TAG_PROTO )
{
bool nodly = ( xml.attributes().value ( ATTR_NODELAY ).toString() == "yes" );
widget->chkNoDelay->setChecked ( nodly );
bool tcp = (xml.readElementText() == "tcp");
widget->radTcp->setChecked ( tcp );
widget->radUdp->setChecked ( !tcp );
}
else if ( xml.name() == TAG_SMS )
{
widget->chkSms->setChecked ( true );
widget->txtSms->setText ( xml.readElementText() );
}
else if ( xml.name() == TAG_SSS )
{
widget->chkSss->setChecked ( true );
widget->txtSss->setText ( xml.readElementText() );
}
else if ( xml.name() == TAG_RMS )
{
widget->chkRms->setChecked ( true );
widget->txtRms->setText ( xml.readElementText() );
}
else if ( xml.name() == TAG_RSS )
{
widget->chkRss->setChecked ( true );
widget->txtRss->setText ( xml.readElementText() );
}
}
}
if ( xml.hasError() )
cerr << "Error in MGEN configuration:\n" << qPrintable ( xml.errorString() );
}
Tlevel::EerrorType Tlevel::loadFromXml(QXmlStreamReader& xml) {
EerrorType er = e_level_OK;
// if (xml.readNextStartElement()) {
if (xml.name() != "level") {
qDebug() << "There is no 'level' key in that XML";
return e_noLevelInXml;
}
name = xml.attributes().value("name").toString();
if (name == "") {
qDebug() << "Level key has empty 'name' attribute";
return e_otherError;
} else if (name.size() > 25) {
name = name.left(25);
er = e_levelFixed;
qDebug() << "Name of a level was reduced to 25 characters:" << name;
}
// }
while (xml.readNextStartElement()) {
if (xml.name() == "description")
desc = xml.readElementText();
// QUESTIONS
else if (xml.name() == "questions") {
while (xml.readNextStartElement()) {
// qDebug() << "questions->" << xml.name();
if (xml.name() == "qaType") {
er = qaTypeFromXml(xml);
if (er == e_otherError)
return er;
} else if (xml.name() == "requireOctave")
requireOctave = QVariant(xml.readElementText()).toBool();
else if (xml.name() == "requireStyle")
requireStyle = QVariant(xml.readElementText()).toBool();
else if (xml.name() == "showStrNr")
showStrNr = QVariant(xml.readElementText()).toBool();
else if (xml.name() == "clef") {
clef.setClef(Tclef::Etype(QVariant(xml.readElementText()).toInt()));
if (clef.name() == "") { // when clef has improper value its name returns ""
qDebug() << "Level had wrong/undefined clef. It was fixed to treble dropped.";
clef.setClef(Tclef::e_treble_G_8down);
er = e_levelFixed;
}
} else if (xml.name() == "instrument") {
instrument = Einstrument(QVariant(xml.readElementText()).toInt());
if (instrumentToText(instrument) == "") {
qDebug() << "Level had wrong instrument type. It was fixed to classical guitar.";
instrument = e_classicalGuitar;
er = e_levelFixed;
}
} else if (xml.name() == "onlyLowPos")
onlyLowPos = QVariant(xml.readElementText()).toBool();
else if (xml.name() == "onlyCurrKey")
onlyCurrKey = QVariant(xml.readElementText()).toBool();
else if (xml.name() == "intonation")
intonation = QVariant(xml.readElementText()).toInt();
else
skipCurrentXmlKey(xml);
}
} else if (xml.name() == "melodies") {
while (xml.readNextStartElement()) {
if (xml.name() == "melodyLength")
melodyLen = qBound(1, QVariant(xml.readElementText()).toInt(), 100);
else if (xml.name() == "endsOnTonic")
endsOnTonic = QVariant(xml.readElementText()).toBool();
else if (xml.name() == "requireInTempo")
requireInTempo = QVariant(xml.readElementText()).toBool();
else
skipCurrentXmlKey(xml);
}
} else if (xml.name() == "accidentals") {
while (xml.readNextStartElement()) {
// qDebug() << "accidentals->" << xml.name();
if (xml.name() == "withSharps")
withSharps = QVariant(xml.readElementText()).toBool();
else if (xml.name() == "withFlats")
withFlats = QVariant(xml.readElementText()).toBool();
else if (xml.name() == "withDblAcc")
withDblAcc = QVariant(xml.readElementText()).toBool();
else if (xml.name() == "useKeySign")
useKeySign = QVariant(xml.readElementText()).toBool();
else if (xml.name() == "loKey") {
xml.readNextStartElement();
loKey.fromXml(xml);
xml.skipCurrentElement();
} else if (xml.name() == "hiKey") {
xml.readNextStartElement();
hiKey.fromXml(xml);
xml.skipCurrentElement();
}
else if (xml.name() == "isSingleKey")
isSingleKey = QVariant(xml.readElementText()).toBool();
else if (xml.name() == "manualKey")
manualKey = QVariant(xml.readElementText()).toBool();
else if (xml.name() == "forceAccids")
forceAccids = QVariant(xml.readElementText()).toBool();
else
skipCurrentXmlKey(xml);
}
} else if (xml.name() == "range") {
// RANGE
while (xml.readNextStartElement()) {
// qDebug() << "range->" << xml.name();
if (xml.name() == "loFret")
fretFromXml(xml, loFret, er);
else if (xml.name() == "hiFret")
fretFromXml(xml, hiFret, er);
else if (xml.name() == "loNote")
loNote.fromXml(xml);
// loNote = tnoteFromXml(xml);
else if (xml.name() == "hiNote")
hiNote.fromXml(xml);
// hiNote = tnoteFromXml(xml);
else if (xml.name() == "useString") {
int id = xml.attributes().value("number").toInt();
if (id > 0 && id < 7)
usedStrings[id - 1] = QVariant(xml.readElementText()).toBool();
} else
skipCurrentXmlKey(xml);
}
} else
skipCurrentXmlKey(xml);
}
if (canBeGuitar() && fixFretRange() == e_levelFixed) {
er = e_levelFixed;
qDebug() << "Lowest fret in range was bigger than the highest one. Fixed";
}
if (useKeySign && !isSingleKey && fixKeyRange() == e_levelFixed) {
er = e_levelFixed;
qDebug() << "Lowest key in range was higher than the highest one. Fixed";
}
if (loNote.note == 0 || hiNote.note == 0) {
qDebug() << "Note range is wrong.";
return e_otherError;
} else if (fixNoteRange() == e_levelFixed) {
er = e_levelFixed;
qDebug() << "Lowest note in range was higher than the highest one. Fixed";
}
if (xml.hasError()) {
qDebug() << "level has error" << xml.errorString() << xml.lineNumber();
return e_otherError;
}
return er;
}
void DataFetcher::parseXml(QXmlStreamReader &xml)
{
bool rootOK = false;
while (!(xml.atEnd() || xml.error())) {
if (xml.readNext() == QXmlStreamReader::StartElement) {
if (xml.name() == "hudson")
rootOK = true;
else if (rootOK && xml.name() == "job")
parseJob(xml);
else
xml.skipCurrentElement();
}
}
if (xml.error()) {
m_errorMessage += "XML ERROR:" + QString::number( xml.lineNumber() ) + ": " + xml.errorString();
qWarning() << m_errorMessage;
}
}
// Data loading
bool NMGStatisticRemoteWidget::loadData ( QString data )
{
QXmlStreamReader xml ( data );
/** \par Received Message Format for "packets" tests
* <data>
* <test type="packets">
* <path>testPath</path>
* <flows>1;3..6;8</flows>
* <statistic>SENT;...;IPDV(P999)</statistic>
* </test>
* </data>
*
* \par Received Message Format for "throughput" tests
* <data>
* <test type="throughput">
* <paths>
* <path>testPath_1</path>
* ...
* <path>testPath_N</path>
* </paths>
* <statistic>MIN;AVE;MAX</statistic>
* </test>
* </data>
*
* \par More Information
* \note The parsers are Case Insensitive
* \note ATTR "type" of <test> should be "packets" (TYPE_PACKETS) or "throughput" (TYPE_TPUT)
* \note TAG <flows> should be like a list of flowIds separated by semicolons like 1;2;3;...;N or ranges like 1..N or ALL
* \note TAG <statistics> should be a list of tags separated by semicolons. Available tags are:
* For "packets" tests:
* ALL (if we want ALL statistics, we only need this tag)
* SENT,
* RECEIVED,
* DURATION,
* LOST,
* LOSS_RATIO,
* DUPLICATED,
* DUPLICATED_RATIO,
* OUTOFORDER,
* OUTOFORDER_RATIO,
* DELAY(AVERAGE,MIN,MAX,STDEV,JITTER,P50,P95,P99,P999) or DELAY() for all values,
* IPDV(AVERAGE,MIN,MAX,STDEV,JITTER,P50,P95,P99,P999) or IPDV() for all values
* For "throughput" tests:
* ALL (if we want ALL statistics, we only need this tag)
* MIN
* MAX
* AVE
**/
bool error = true;
while ( !xml.atEnd() )
{
xml.readNext();
if ( xml.isStartElement() )
{
if ( xml.name() == TAG_DATA ) error = false;
else if ( xml.name() == TAG_TEST and !error )
{
if ( QString::compare ( xml.attributes().value ( ATTR_TYPE ).toString(),
TYPE_PACKETS, Qt::CaseInsensitive ) == 0 )
error = loadPacketData ( &xml );
else if ( QString::compare ( xml.attributes().value ( ATTR_TYPE ).toString(),
TYPE_TPUT, Qt::CaseInsensitive ) == 0 )
error = loadThroughtputData ( &xml );
}
else
{
xml.raiseError ( "[ERROR] Error in XML format" );
error = true;
}
}
}
if ( xml.hasError() )
cout << qPrintable ( xml.errorString () ) << endl;
return !error;
}
void CoordXmlTest::readHumanReadableStream()
{
namespace literal = XmlStreamLiteral;
QFETCH(int, num_coords);
MapCoordVector coords(num_coords, proto_coord);
buffer.buffer().truncate(0);
QBuffer header;
{
QXmlStreamWriter xml(&header);
header.open(QBuffer::ReadWrite);
xml.setAutoFormatting(false);
xml.writeStartDocument();
xml.writeStartElement("root");
xml.writeCharacters(""); // flush root start element
buffer.open(QBuffer::ReadWrite);
xml.setDevice(&buffer);
xml.writeStartElement("coords");
// Using the more efficient string implementation.
writeHumanReadableString_implementation(coords, xml);
xml.writeEndElement();
xml.setDevice(NULL);
buffer.close();
header.close();
}
header.open(QBuffer::ReadOnly);
buffer.open(QBuffer::ReadOnly);
QXmlStreamReader xml;
xml.addData(header.buffer());
xml.readNextStartElement();
QCOMPARE(xml.name().toString(), QString("root"));
bool failed = false;
QBENCHMARK
{
// benchmark iteration overhead
coords.clear();
xml.addData(buffer.data());
xml.readNextStartElement();
if (xml.name() != "coords")
{
failed = true;
break;
}
for( xml.readNext();
xml.tokenType() != QXmlStreamReader::EndElement;
xml.readNext() )
{
if (xml.error())
{
qDebug() << xml.errorString();
failed = true;
break;
}
const QXmlStreamReader::TokenType token = xml.tokenType();
if (token == QXmlStreamReader::EndDocument)
{
failed = true;
break;
}
if (token == QXmlStreamReader::Characters && !xml.isWhitespace())
{
QStringRef text = xml.text();
QString data = QString::fromRawData(text.constData(), text.length());
QTextStream stream(&data, QIODevice::ReadOnly);
stream.setIntegerBase(10);
while (!stream.atEnd())
{
qint32 x, y;
int flags = 0;
char separator;
stream >> x >> y >> separator;
if (separator != ';')
{
stream >> flags >> separator;
}
coords.push_back(MapCoord::fromNative(x, y, flags));
}
if (stream.status() == QTextStream::ReadCorruptData)
{
failed = true;
break;
}
}
// otherwise: ignore element
}
static QString msgXmlError(const QXmlStreamReader &r, const QString& fileName)
{
return QString::fromUtf8("An error has been encountered at line %1 of %2: %3:").arg(r.lineNumber()).arg(fileName, r.errorString());
}
static inline QString msgXmlError(const QString &fileName, const QXmlStreamReader &r)
{
return QDesignerWidgetBox::tr("An error has been encountered at line %1 of %2: %3")
.arg(r.lineNumber()).arg(fileName, r.errorString());
}
