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);
}
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;
}
void Matrix::load(QXmlStreamReader& xml)
{
Q_ASSERT(xml.name() == "matrix");
int new_n = qMax(0, xml.attributes().value("n").toString().toInt());
int new_m = qMax(0, xml.attributes().value("m").toString().toInt());
setSize(new_n, new_m);
int count = n*m;
int i = 0;
while (xml.readNextStartElement())
{
if (i < count && xml.name() == "element")
{
d[i] = xml.attributes().value("value").toString().toDouble();
i++;
}
xml.skipCurrentElement();
}
if (i < count)
{
qDebug() << "Too few elements for a" << new_n << "x" << new_m
<< "matrix at line" << xml.lineNumber();
}
}
static inline QString msgError(const QXmlStreamReader &reader,
const QString &fileName,
const QString &what)
{
return QString::fromLatin1("Error in %1 at line %2, column %3: %4").
arg(fileName).arg(reader.lineNumber()).arg(reader.columnNumber()).arg(what);
}
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;
}
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;
}
StorageParserException::StorageParserException( const QString &s, const QXmlStreamReader &xml )
: StorageException( s ),
m_element( xml.name().toString() ),
m_line( xml.lineNumber() ),
m_column( xml.columnNumber() ),
m_characterOffset( xml.characterOffset() )
{
}
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
SoundSettings::loadXML (
const QString &xmlFileName,
QString &origFileName,
QString ©FileName,
QString &title)
{
QFile *file = 0;
QXmlStreamReader *xml = 0;
bool retval = false;
QStringList names;
SYS_DEBUG ("*** xmlFileName = %s", SYS_STR(xmlFileName));
file = new QFile(xmlFileName);
if (!file || !file->open(QIODevice::ReadOnly | QIODevice::Text))
{
SYS_WARNING ("Can not open '%s' for reading: %m",
SYS_STR(xmlFileName));
goto finalize;
}
xml = new QXmlStreamReader(file);
while(!xml->atEnd() && !xml->hasError()) {
QString name(xml->name().toString());
#if 0
SYS_DEBUG ("*************************************");
SYS_DEBUG ("*** name: %s", SYS_STR(name));
SYS_DEBUG ("*** lineNumber : %d", xml->lineNumber());
#endif
if (xml->isStartElement()) {
names << xml->name().toString();
} else if (xml->isEndElement()) {
names.removeLast();
} else if (xml->isCharacters()) {
QString path = names.join("/");
if (path == "soundsettings-applet/orig-file")
origFileName = xml->text().toString();
else if (path == "soundsettings-applet/copy-file")
copyFileName = xml->text().toString();
else if (path == "soundsettings-applet/title")
title = xml->text().toString();
}
xml->readNext();
}
finalize:
if (xml)
delete xml;
if (file)
delete file;
return retval;
}
bool Board::load(std::string cells_param)
{
ROS_DEBUG("Ready to read xml data of cells");
std::string xml_cells;
if (ros::param::get(cells_param, xml_cells)) //reading the xml data from the parameter server
{
cells.clear(); //cleaning all previous cells
QXmlStreamReader xml;
xml.addData(QString::fromStdString(xml_cells)); //adding the xml content to the input stream
while(!xml.atEnd() && !xml.hasError()) {
/* Read next element.*/
QXmlStreamReader::TokenType token = xml.readNext();
ROS_DEBUG_STREAM("name=" << xml.name().toString().toStdString());
/* If token is just StartDocument, we'll go to next.*/
if(token == QXmlStreamReader::StartDocument) {
continue;
}
/* If token is StartElement, we'll see if we can read it.*/
if(token == QXmlStreamReader::StartElement) {
/* If it's named cell, we'll add a new cell to the board.*/
if(xml.name() == "cell") {
cells.push_back(Cell());
continue;
}
/* If it's named vertex, we'll dig the information from there.*/
if(xml.name() == "vertex") {
/* Let's get the attributes for vertex */
QXmlStreamAttributes attributes = xml.attributes();
/* Let's check that vertex has x and y attribute. */
if(attributes.hasAttribute("x") && attributes.hasAttribute("y")) {
/* We'll add it to the cell */
cells.back().contours.push_back(cv::Point(attributes.value("x").toString().toInt(), attributes.value("y").toString().toInt()));
}
else xml.raiseError("Vertex corrupted: x and/or y value is missing");
}
}
}
ROS_WARN_COND(xml.hasError(),"Error parsing xml data (l.%d, c.%d):%s", (int)xml.lineNumber(), (int)xml.columnNumber(), xml.errorString().toStdString().c_str());
ROS_INFO("Xml data successfully loaded. %i cells loaded.", (int)cells.size());
for (int i = 0; i < cells.size(); ++i)
{
ROS_INFO("Cell %i: %s",i,cells[i].toString().c_str());
}
return true;
}
else
{
ROS_FATAL_STREAM("xml cell data not loaded!");
return false;
}
}
/**
* Extract language related XML attributs from XMI file
* @param fileName file to extract attributes from
* @param attributes List with attribute names to extract
* @param result map with extracted results
* @return true successful extraction
* @return false extraction failure
*/
bool extractAttributesFromXMI(const char *fileName, const QStringList &attributes, POMap &result)
{
QFile file(fileName);
QXmlStreamReader xmlReader;
if(!file.open(QIODevice::ReadOnly))
return false;
xmlReader.setDevice(&file);
while (!xmlReader.atEnd()) {
QXmlStreamReader::TokenType type = xmlReader.readNext();
if (type != QXmlStreamReader::StartElement)
continue;
foreach(const QString &attributeName, attributes) {
if (!xmlReader.attributes().hasAttribute(attributeName))
continue;
QString value = xmlReader.attributes().value(attributeName).toString();
if (value.isEmpty())
continue;
QString tagName = xmlReader.name().toString() + ':' + attributeName;
QString key = value;
if (result.contains(key)) {
result[key].lineNumbers.append(xmlReader.lineNumber());
result[key].tagNames.append(tagName);
} else {
POEntry entry;
entry.tagNames.append(tagName);
entry.value = value;
entry.lineNumbers.append(xmlReader.lineNumber());
result[key] = entry;
}
}
}
if (xmlReader.hasError()) {
std::cerr << "Parsing failed." << std::endl;
return false;
}
return true;
}
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;
}
void cProfileSettings::load ()
{
cProfileManager *pm = cProfileManager::self();
QString path = pm->profilePath (d->profileId);
QDir dir = QDir (path);
if (!dir.exists()) QDir::root().mkpath (dir.absolutePath());
QFile f (path + "/settings.xml");
if (!f.open(QIODevice::ReadOnly | QIODevice::Text)) {
kWarning() << "No settings file - nothing to do." << endl;
return; // no profiles - nothing to do
}
QXmlStreamReader *reader = new QXmlStreamReader (&f);
reader->readNext (); // read the document start
reader->readNext ();
if (reader->isStartElement ())
if (reader->name() == "profile")
if (reader->attributes().value ("version") == "1.0") {
// okay, read the list
while (!reader->atEnd()) {
reader->readNext ();
if (reader->isStartElement () && (reader->name() == "setting")) {
QString type = reader->attributes().value ("type").toString();
QString name = reader->attributes().value ("name").toString();
QString value = reader->attributes().value ("value").toString();
if (type == "integer")
setInt (name, value.toInt());
else if (type == "bool")
setBool (name, (value == "true"));
else if (type == "string")
setString (name, value);
else
kDebug() << "Unrecognized setting type " << type << endl;
}
}
} else reader->raiseError ("Unknown profile file version.");
else reader->raiseError ("This is not a valid profile list file.");
else reader->raiseError ("This file is corrupted.");
if (reader->hasError()) {
kWarning() << ("Error in settings.xml at line " + QString::number (reader->lineNumber()) + ", column " + QString::number (reader->columnNumber()) + QString (": ") + reader->errorString()) << endl;
}
// close the file
f.close ();
delete reader;
}
static void raiseError(QXmlStreamReader &reader, const QString &error, Settings::ParseMode parseMode)
{
if (parseMode == Settings::StrictParseMode) {
reader.raiseError(error);
} else {
QFile *xmlFile = qobject_cast<QFile*>(reader.device());
if (xmlFile) {
qWarning().noquote().nospace()
<< "Ignoring following settings reader error in " << xmlFile->fileName()
<< ", line " << reader.lineNumber() << ", column " << reader.columnNumber()
<< ": " << error;
} else {
qWarning("Ignoring following settings reader error: %s", qPrintable(error));
}
}
}
/*!
\internal
Processes a list of floating point numbers. If the list contains only 1
element, a QVariant<float> is returned. If the list containst 2, 3 or 4
elements, they are converted into a QVariant containing a QVector2D,
QVector3D, or QVector4D respectively.
If the list containst more elements than that, they are returned as a
QArray<float>.
*/
QVariant QGLColladaFxEffectFactory::processFloatList( QXmlStreamReader& xml )
{
QArray<float> floats;
QString elementString = xml.readElementText();
QStringList list = elementString.split( QRegExp( "\\s+" ), QString::SkipEmptyParts );
bool ok;
float f;
foreach( QString string, list )
{
f = string.toFloat( &ok );
if( ok )
floats.append(string.toFloat());
else
{
qWarning() << "Warning: malformed float ( line" << xml.lineNumber() << ")";
}
}
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;
}
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;
}
}
void readXML(QString filename, exprNode* expr1, exprNode* expr2, QMap<QString, DataVariable>& listVar)
{
//Данных для вывести ошибки
QString russia = "йцукенгшщзхъфывапролджэячсмитьбюёЙЦУКЕНГШЩЗХЪЁФЫВАПРОЛДЖЭЯЧСМИТЬБЮ"; //русские буквы
QString message; // сообщение об ошибке
QString formula; //индекс выражения
int lineOpenOperator; //индекс строки начального тега оператора
int lineCloseOperator; //индекс строки конечного тега оператора
QFile input(filename);
if (!input.open(QFile::ReadOnly | QFile::Text))
{
throw "file don't extsting";
}
QXmlStreamAttributes attr;
//5. Считывание данных из XML-файла происходит средствами библиотеки
//Qt методом потокового чтения QXmlStreamReader.
QXmlStreamReader xmlStream;
xmlStream.setDevice(&input);
//Прочитать первую строку в XML файл
xmlStream.readNext();
xmlStream.readNext();
xmlStream.readNext();
xmlStream.readNext();
//6.Создать указатель currentNode, который будет указывать на текущий узел.
exprNode* currentNode;
//7. До конца XML файла
while (!xmlStream.atEnd())
{
if (xmlStream.name().toString() == "test1" && xmlStream.isEndElement()) break;
//7.1. Если полученный начальный тег является тегом “formula1” или “formula2”,
//то соответственно выбирать правильный разбор дерева expr1, expr2 для сохранения.
//Присвоить currentNode на expr1 или expr2 соответственно.
if (xmlStream.name().toString() == "formula1" || xmlStream.name().toString() == "formula2")
{
//Если полученный начальный тег является тегом “formula1”
if (xmlStream.isStartElement())
{
if (xmlStream.name().toString() == "formula1")
{
currentNode = expr1;
formula = "1";
}
//Если полученный начальный тег является тегом “formula2”,
else
{
currentNode = expr2;
formula = "2";
}
//Присвоить curerntNode на текущий опретор
xmlStream.readNext();
xmlStream.readNext();
currentNode->type = returnExprNodeTypeAtQString[xmlStream.name().toString()];
lineOpenOperator = xmlStream.lineNumber(); //Обновить индекс начального тега
// Перейти к следующему тегу
xmlStream.readNext();
xmlStream.readNext();
}
//Если полученный тег является последним, то идти дальше
else if (xmlStream.isEndElement())
{
xmlStream.readNext();
xmlStream.readNext();
}
}
//7.2.Если полученный тег является операцией
else if (xmlStream.name().toString() == "plus" || xmlStream.name().toString() == "minus" || xmlStream.name().toString() == "multi" || xmlStream.name().toString() == "devide" || xmlStream.name().toString() == "mod" || xmlStream.name().toString() == "prefixInc" ||
xmlStream.name().toString() == "prefixDec" || xmlStream.name().toString() == "postfixInc" || xmlStream.name().toString() == "postfixDec" ||
xmlStream.name().toString() == "assignment" || xmlStream.name().toString() == "addAssign" || xmlStream.name().toString() == "subAssign" ||
xmlStream.name().toString() == "multiAssign" || xmlStream.name().toString() == "divideAssign" || xmlStream.name().toString() == "abs" ||
xmlStream.name().toString() == "pow" || xmlStream.name().toString() == "sqrt" || xmlStream.name().toString() == "fmax" || xmlStream.name().toString() == "fmin")
{
//Если полученный тег является начальной
if (xmlStream.isStartElement())
{
lineOpenOperator = xmlStream.lineNumber(); //Обновить индекс начального тега
//7.2.1.Создать новый узел newNode у класса exprNode, который сохраняет данные из тега.
exprNode* newNode=new exprNode;
//7.2.2. Указать родительский узел у узла newNode на currentNode.
newNode->fatherOperand = currentNode;
//7.2.3. Данный узел будет находиться в левом currentNode, если указатель leftOperand свободен, иначе в правом rightOpernand.
if (currentNode->leftOperand == NULL) currentNode->leftOperand = newNode;
else
currentNode->rightOperand = newNode;
//Присвоить тип оператора в newNode->type
newNode->type = returnExprNodeTypeAtQString[xmlStream.name().toString()];
//Присвоить текущий узел на newNode
currentNode = newNode;
// Перейти к следующему тегу
xmlStream.readNext();
xmlStream.readNext();
}
//7.3.Если полученный тег является последним
else if (xmlStream.isEndElement())
{
lineCloseOperator = xmlStream.lineNumber(); //Обновить индекс конечного тега
//Ошибка.Выражение введено не полностью
if (xmlStream.name().toString() == "prefixInc" || xmlStream.name().toString() == "prefixDec" || xmlStream.name().toString() == "postfixInc" || xmlStream.name().toString() == "postfixDec" || xmlStream.name().toString() == "abs" || xmlStream.name().toString() == "sqrt")
{
if (currentNode->leftOperand == NULL)
{
message = "В формуле " + formula + ", на строке " + QString::number(lineOpenOperator) + "-" + QString::number(lineCloseOperator) + ", в операции " + xmlStream.name().toString() + " не хватает операторов";
throw(message);
}
}
else
{
if (currentNode->leftOperand == NULL || currentNode->rightOperand == NULL)
{
message = "В формуле " + formula + ", на строке " + QString::number(lineOpenOperator) + "-" + QString::number(lineCloseOperator) + ", в операции " + xmlStream.name().toString() + " не хватает операторов";
throw(message);
}
}
//// Перейти к следующему тегу
xmlStream.readNext();
xmlStream.readNext();
currentNode = currentNode->fatherOperand; //вернуть указатель currentNode на родителей узел
}
}
else
{
exprNode* newNode = new exprNode;
//7.2.4.Если полученный тег обозначает число
if (xmlStream.name().toString() == "const")
{
attr = xmlStream.attributes(); //Получать все атрибуты внутри тега
//Ошибка.Присваивания при константном правом операнде (не l-value)
if (currentNode->type == prefixInc || currentNode->type == prefixDec || currentNode->type == postfixInc ||
currentNode->type == postfixDec || currentNode->type == assignment || currentNode->type == addAssign ||
currentNode->type == subAssign || currentNode->type == multiAssign || currentNode->type == divideAssign)
if (currentNode->leftOperand == NULL)
{
int currentLine = xmlStream.lineNumber();
message = "В формуле " + formula + ", в строке " + QString::number(currentLine) + ", присваивается значение константа";
throw(message);
}
//7.2.4.2.Установить поле numbervalue и type у newNode в значение числа и типа данных.
newNode->type = returnExprNodeTypeAtQString[xmlStream.name().toString()];
newNode->numbervalue = attr.value("value").toLongLong();
//// Перейти к следующему тегу
xmlStream.readNext();
xmlStream.readNext();
xmlStream.readNext();
}
//7.2.5. Если полученный тег обозначает переменную
else if (xmlStream.name().toString() == "var")
{
attr = xmlStream.attributes();//Получать все атрибуты внутри тега
newNode->type = returnExprNodeTypeAtQString[xmlStream.name().toString()]; //Установить поле type у newNode в значение типа данных.
newNode->namevar = attr.value("name").toString(); //Добавить имена переменные в поле namevar у newNode.
//Ошибка. В названии переменных используются нелатинские буквы.
if (russia.contains(newNode->namevar))
{
message = "В формуле " + formula + " имя переменной " + newNode->namevar + " должно быть задано латинскими буквами";
throw(message);
}
//Ошибка. Заданные диапазоны не соответствуют типам данных
if (attr.value("type").toString() != "char" && attr.value("type").toString() != "unsigned char" && attr.value("type").toString() != "int" && attr.value("type").toString() != "long" && attr.value("type").toString() != "unsigned long")
{
message = "В формуле " + formula + ", у переменной " + newNode->namevar + " тип данных задан не верно";
throw(message);
}
//Ошибка.Переменные введены без типа данных
if (attr.value("type") == "")
{
message = "В формуле " + formula + ", переменная «а» задана без типа данных";
throw(message);
}
//Ошибка.Переменные введены без диапазона
if (attr.value("from") == "" || attr.value("to") == "")
{
message = "В формуле " + formula + ", переменная "+newNode->namevar +" задана без диапазона";
throw(message);
}
//Получить информации о диапозоне и типе данных в теге
DataVariable tempvar;
tempvar.typevar = attr.value("type").toString();
tempvar.lowEdge = attr.value("from").toLongLong();
tempvar.highEdge = attr.value("to").toLongLong();
//Ошибка.Нелогично задан интервал
if (tempvar.highEdge < tempvar.lowEdge)
{
message = "В формуле " + formula + ", у переменной " + newNode->namevar + " диапазон задан не верно";
throw (message);
}
//Ошибка.Задается одна и та же переменная с разными типами данных или с разными диапазонами в двух выражениях
if (listVar.contains(newNode->namevar))
{
if (listVar.value(newNode->namevar).lowEdge != tempvar.lowEdge || listVar.value(newNode->namevar).highEdge != tempvar.highEdge)
{
message = "Переменная " + newNode->namevar + " в разных выражениях определяется по-разному";
throw (message);
}
}
else
//7.2.5.4. Добавить в список переменных listVar имена переменные с диапазоном и типом данных.
listVar.insert(newNode->namevar, tempvar);
//// Перейти к следующему тегу
xmlStream.readNext();
xmlStream.readNext();
xmlStream.readNext();
}
//7.2.3. Указать родительский узел у узла newNode на currentNode.
newNode->fatherOperand = currentNode;
//7.2.2. Данный узел будет находиться в левом currentNode, если указатель leftOperand свободен, иначе в правом rightOpernand
if (currentNode->leftOperand == NULL) currentNode->leftOperand = newNode;
else
currentNode->rightOperand = newNode;
}
}
}
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;
}
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 GdalAdapter::fromXML(QXmlStreamReader& stream)
{
theBbox = QRectF();
theImages.clear();
while(!stream.atEnd() && !stream.isEndElement()) {
if (stream.name() == "Images") {
if (stream.attributes().hasAttribute("projection"))
theProjection = stream.attributes().value("projection").toString();
if (stream.attributes().hasAttribute("source"))
theSourceTag = stream.attributes().value("source").toString();
stream.readNext();
while(!stream.atEnd() && !stream.isEndElement()) {
if (stream.name() == "Image") {
QString fn = stream.attributes().value("filename").toString();
if (!fn.isEmpty())
loadImage(fn);
stream.readNext();
} else if (!stream.isWhitespace()) {
qDebug() << "gdalimage: logic error: " << stream.name() << " : " << stream.tokenType() << " (" << stream.lineNumber() << ")";
stream.skipCurrentElement();
}
stream.readNext();
}
} else if (!stream.isWhitespace()) {
qDebug() << "gdalmain: logic error: " << stream.name() << " : " << stream.tokenType() << " (" << stream.lineNumber() << ")";
stream.skipCurrentElement();
}
stream.readNext();
}
}
HangingProtocol* HangingProtocolXMLReader::readFile(const QString &path)
{
QFile file(path);
HangingProtocol *hangingProtocolLoaded = NULL;
if (!file.open(QFile::ReadOnly | QFile::Text))
{
QMessageBox::warning(0, tr("Hanging Protocol XML File"),
tr("Unable to read file %1:\n%2.")
.arg(path)
.arg(file.errorString()));
return NULL;
}
QXmlStreamReader *reader = new QXmlStreamReader(&file);
if (reader->readNextStartElement())
{
if (reader->name() == "hangingProtocol")
{
HangingProtocol *hangingProtocol = new HangingProtocol();
QStringList protocols;
QList<HangingProtocolImageSet::Restriction> restrictionList;
while (reader->readNextStartElement())
{
if (reader->name() == "hangingProtocolName")
{
hangingProtocol->setName(reader->readElementText());
}
else if (reader->name() == "numberScreens")
{
hangingProtocol->setNumberOfScreens(reader->readElementText().toInt());
}
else if (reader->name() == "protocol")
{
protocols << reader->readElementText();
}
else if (reader->name() == "institutions")
{
hangingProtocol->setInstitutionsRegularExpression(QRegExp(reader->readElementText(), Qt::CaseInsensitive));
}
else if (reader->name() == "restriction")
{
restrictionList << readRestriction(reader);
}
else if (reader->name() == "imageSet")
{
HangingProtocolImageSet *imageSet = readImageSet(reader, restrictionList);
hangingProtocol->addImageSet(imageSet);
}
else if (reader->name() == "displaySet")
{
HangingProtocolDisplaySet *displaySet = readDisplaySet(reader, hangingProtocol);
hangingProtocol->addDisplaySet(displaySet);
}
else if (reader->name() == "strictness")
{
hangingProtocol->setStrictness(reader->readElementText().contains("yes"));
}
else if (reader->name() == "allDifferent")
{
hangingProtocol->setAllDiferent(reader->readElementText().contains("yes"));
}
else if (reader->name() == "iconType")
{
hangingProtocol->setIconType(reader->readElementText());
}
else if (reader->name() == "hasPrevious")
{
hangingProtocol->setPrevious(reader->readElementText().contains("yes"));
}
else if (reader->name() == "priority")
{
hangingProtocol->setPriority(reader->readElementText().toDouble());
}
else
{
reader->skipCurrentElement();
}
}
if (!reader->hasError())
{
hangingProtocol->setProtocolsList(protocols);
hangingProtocolLoaded = hangingProtocol;
}
else
{
delete hangingProtocol;
}
}
}
if (reader->hasError())
{
DEBUG_LOG(QString("[Line: %1, Column:%2] Error in hanging protocol file %3: %4, error: %5").arg(reader->lineNumber()).arg(reader->columnNumber()).arg(
path).arg(reader->errorString()).arg(reader->error()));
ERROR_LOG(QString("[Line: %1, Column:%2] Error in hanging protocol file %3: %4, error: %5").arg(reader->lineNumber()).arg(reader->columnNumber()).arg(
path).arg(reader->errorString()).arg(reader->error()));
}
delete reader;
return hangingProtocolLoaded;
}
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());
}
TrainingSetFile::TSFResult TrainingSetFile::fromFile(QFile &file)
{
QString
version,
text;
QStringRef name;
QXmlStreamReader tsReadXML;
QXmlStreamReader::TokenType tt;
QStringList textElements;
QXmlStreamAttributes attributes;
TrainingSetFile *retTSF = new TrainingSetFile();
TSFResult res = {retTSF, true, NoError, "", 0};
TrainingSet *ts = retTSF->getTrainingSet();
int
lastPatternIndex = 0,
sTextElements,
pSize = 0,
iSize = 0,
tSize = 0;
Normalization
*inor = new Normalization(),
*tnor = new Normalization();
vector<vector<double> >
inputs,
targets;
DataRepresentation
*idr = ts->getInputsDataRepresentation(),
*tdr = ts->getTargetsDataRepresentation();
if(file.open(QIODevice::ReadOnly)){
tsReadXML.setDevice(&file);
while (!tsReadXML.atEnd()) {
tt = tsReadXML.readNext();
if(tsReadXML.hasError()){
file.close();
return {retTSF, false, toTSFError(tsReadXML.error()), tsReadXML.errorString(), tsReadXML.lineNumber()};
}
if(tt == QXmlStreamReader::StartDocument){
continue;
}else if(tt == QXmlStreamReader::StartElement){
name = tsReadXML.name();
if(name == STR_TRAININGSET){
attributes = tsReadXML.attributes();
if(attributes.hasAttribute(STR_PATTERNSIZE) &&
attributes.hasAttribute(STR_INPUTSSIZE) &&
attributes.hasAttribute(STR_TARGETSSIZE))
{
pSize = attributes.value(STR_PATTERNSIZE).toInt();
iSize = attributes.value(STR_INPUTSSIZE).toInt();
tSize = attributes.value(STR_TARGETSSIZE).toInt();
inputs = vector<vector<double> >(pSize, vector<double>(iSize, 0));
targets = vector<vector<double> >(pSize, vector<double>(tSize, 0));
}else{
file.close();
return {
retTSF, false, NotWellFormedError, "NotWellFormedError: Missing attributes (" + STR_PATTERNSIZE + ", " + STR_INPUTSSIZE + ", " + STR_TARGETSSIZE + ") on tag " + STR_TRAININGSET, tsReadXML.lineNumber()
};
}
}else if(name == STR_PROPERTIES){
attributes = tsReadXML.attributes();
if(attributes.hasAttribute(STR_VERSION)){
version = attributes.value(STR_VERSION).toString();
}else{
file.close();
return
{
retTSF, false, NotWellFormedError, "NotWellFormedError: Missing attributes (" + STR_VERSION + ") on tag " + STR_PROPERTIES, tsReadXML.lineNumber()
};
}
}else if(name == STR_INPUTSDATAREPRESENTATION){
attributes = tsReadXML.attributes();
if(attributes.hasAttribute(STR_NAME) &&
attributes.hasAttribute(STR_WIDTH) &&
attributes.hasAttribute(STR_HEIGHT) &&
attributes.hasAttribute(STR_FORMAT))
{
idr->setType(drFromStrToInt(attributes.value(STR_NAME).toString()));
idr->setWidth(attributes.value(STR_WIDTH).toInt());
idr->setHeight(attributes.value(STR_HEIGHT).toInt());
idr->setImageFormat(fromStrToImgFormat(attributes.value(STR_FORMAT).toString()));
}else{
file.close();
return
{
retTSF, false, NotWellFormedError, "NotWellFormedError: Missing attributes (" + STR_NAME + ", " + STR_WIDTH + ", " + STR_HEIGHT + ", " + STR_FORMAT + ") on tag " + STR_INPUTSDATAREPRESENTATION, tsReadXML.lineNumber()
};
}
}else if(name == STR_TARGETSDATAREPRESENTATION){
attributes = tsReadXML.attributes();
if(attributes.hasAttribute(STR_NAME) &&
attributes.hasAttribute(STR_WIDTH) &&
attributes.hasAttribute(STR_HEIGHT) &&
attributes.hasAttribute(STR_FORMAT))
{
tdr->setType(drFromStrToInt(attributes.value(STR_NAME).toString()));
tdr->setWidth(attributes.value(STR_WIDTH).toInt());
tdr->setHeight(attributes.value(STR_HEIGHT).toInt());
tdr->setImageFormat(fromStrToImgFormat(attributes.value(STR_FORMAT).toString()));
}else{
file.close();
return
{
retTSF, false, NotWellFormedError, "NotWellFormedError: Missing attributes (" + STR_NAME + ", " + STR_WIDTH + ", " + STR_HEIGHT + ", " + STR_FORMAT + ") on tag " + STR_TARGETSDATAREPRESENTATION, tsReadXML.lineNumber()
};
}
}else if(name == STR_INPUTSNORMALIZATION){
attributes = tsReadXML.attributes();
if(attributes.hasAttribute(STR_TYPE) &&
attributes.hasAttribute(STR_MAXVALUE) &&
attributes.hasAttribute(STR_MINVALUE) &&
attributes.hasAttribute(STR_THRESHOLD) &&
attributes.hasAttribute(STR_AMPLITUDE) &&
attributes.hasAttribute(STR_ELONGATION))
{
inor->setType(normFromStrToInt(attributes.value(STR_TYPE).toString()));
inor->setMaxValue(attributes.value(STR_MAXVALUE).toDouble());
inor->setMinValue(attributes.value(STR_MINVALUE).toDouble());
inor->setThreshold(attributes.value(STR_THRESHOLD).toDouble());
inor->setAmplitude(attributes.value(STR_AMPLITUDE).toDouble());
inor->setElongation(attributes.value(STR_ELONGATION).toDouble());
}else{
file.close();
return
{
retTSF, false, NotWellFormedError, "NotWellFormedError: Missing attributes (" + STR_TYPE + ", " + STR_MAXVALUE + ", " + STR_MINVALUE + ", " + STR_THRESHOLD + ", " + STR_ELONGATION + ") on tag " + STR_INPUTSNORMALIZATION, tsReadXML.lineNumber()
};
}
}else if(name == STR_TARGETSNORMALIZATION){
attributes = tsReadXML.attributes();
if(attributes.hasAttribute(STR_TYPE) &&
attributes.hasAttribute(STR_MAXVALUE) &&
attributes.hasAttribute(STR_MINVALUE) &&
attributes.hasAttribute(STR_THRESHOLD) &&
attributes.hasAttribute(STR_AMPLITUDE) &&
attributes.hasAttribute(STR_ELONGATION))
{
tnor->setType(normFromStrToInt(attributes.value(STR_TYPE).toString()));
tnor->setMaxValue(attributes.value(STR_MAXVALUE).toDouble());
tnor->setMinValue(attributes.value(STR_MINVALUE).toDouble());
tnor->setThreshold(attributes.value(STR_THRESHOLD).toDouble());
tnor->setAmplitude(attributes.value(STR_AMPLITUDE).toDouble());
tnor->setElongation(attributes.value(STR_ELONGATION).toDouble());
}else{
file.close();
return
{
retTSF, false, NotWellFormedError, "NotWellFormedError: Missing attributes (" + STR_TYPE + ", " + STR_MAXVALUE + ", " + STR_MINVALUE + ", " + STR_THRESHOLD + ", " + STR_ELONGATION + ") on tag " + STR_TARGETSNORMALIZATION, tsReadXML.lineNumber()
};
}
}else if(name == STR_PATTERN){
attributes = tsReadXML.attributes();
if(attributes.hasAttribute(STR_INDEX))
{
lastPatternIndex = attributes.value(STR_INDEX).toInt();
}else{
file.close();
return
{
retTSF, false, NotWellFormedError, "NotWellFormedError: Missing attributes (" + STR_INDEX + ") on tag " + STR_PATTERN, tsReadXML.lineNumber()
};
}
}else if(name == STR_INPUTS){
text = tsReadXML.readElementText(QXmlStreamReader::SkipChildElements);
textElements = text.split(STR_SEPARATOR, QString::KeepEmptyParts, Qt::CaseInsensitive);
sTextElements = textElements.size();
if(sTextElements == iSize){
for(int i = 0; i < sTextElements; i++){
inputs[lastPatternIndex][i] = textElements[i].toDouble();
}
}else{
file.close();
return
{
retTSF, false, NotWellFormedError, "NotWellFormedError: Incongruence between reported input size with found inputs elements", tsReadXML.lineNumber()
};
}
}else if(name == STR_TARGETS){
text = tsReadXML.readElementText(QXmlStreamReader::SkipChildElements);
textElements = text.split(STR_SEPARATOR, QString::KeepEmptyParts, Qt::CaseInsensitive);
sTextElements = textElements.size();
if(sTextElements == tSize){
for(int t = 0; t < sTextElements; t++){
targets[lastPatternIndex][t] = textElements[t].toDouble();
}
}else{
file.close();
return
{
retTSF, false, NotWellFormedError, "NotWellFormedError: Incongruence between reported target size with found target elements", tsReadXML.lineNumber()
};
}
}
}
}
retTSF->setFileName(file.fileName());
res.file = retTSF;
ts->setPatternCount(pSize);
ts->setInputs(inputs, iSize);
ts->setTargets(targets, tSize);
ts->setInputsNormalization(inor);
ts->setTargetsNormalization(tnor);
ts->setInputsDataRepresentation(idr);
ts->setTargetsDataRepresentation(tdr);
res.sucess = true;
res.errnum = toTSFError(QXmlStreamReader::NoError);
res.errormsg = "";
res.line = -1;
file.close();
return res;
}else{
file.close();
return
{
retTSF, false, toTSFError(file.error()), file.errorString(), -1
};
}
}
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());
}
bool OsmAnd::FavoriteLocationsGpxCollection_P::loadFrom(QXmlStreamReader& xmlReader)
{
std::shared_ptr< FavoriteLocation > newItem;
QList< std::shared_ptr< FavoriteLocation > > newItems;
while (!xmlReader.atEnd() && !xmlReader.hasError())
{
xmlReader.readNext();
const auto tagName = xmlReader.name();
if (xmlReader.isStartElement())
{
if (tagName == QLatin1String("wpt"))
{
if (newItem)
{
LogPrintf(LogSeverityLevel::Warning, "Malformed favorites GPX file: unpaired <wpt>");
return false;
}
bool ok = true;
const double lat = xmlReader.attributes().value(QLatin1String("lat")).toDouble(&ok);
if (!ok)
{
LogPrintf(LogSeverityLevel::Warning, "Malformed favorites GPX file: invalid latitude");
return false;
}
const double lon = xmlReader.attributes().value(QLatin1String("lon")).toDouble(&ok);
if (!ok)
{
LogPrintf(LogSeverityLevel::Warning, "Malformed favorites GPX file: invalid longitude");
return false;
}
newItem.reset(new FavoriteLocation(LatLon(lat, lon)));
}
else if (tagName == QLatin1String("name"))
{
if (!newItem)
{
LogPrintf(LogSeverityLevel::Warning, "Malformed favorites GPX file: unpaired <name>");
return false;
}
newItem->setTitle(xmlReader.readElementText());
}
else if (tagName == QLatin1String("category"))
{
if (!newItem)
{
LogPrintf(LogSeverityLevel::Warning, "Malformed favorites GPX file: unpaired <category>");
return false;
}
const auto& group = xmlReader.readElementText();
if (!group.isEmpty())
newItem->setGroup(group);
}
else if (tagName == QLatin1String("color"))
{
if (!newItem)
{
LogPrintf(LogSeverityLevel::Warning, "Malformed favorites GPX file: unpaired <color>");
return false;
}
bool ok = false;
const auto color = Utilities::parseColor(xmlReader.readElementText(), ColorARGB(), &ok);
if (!ok)
{
LogPrintf(LogSeverityLevel::Warning, "Malformed favorites GPX file: invalid color");
continue;
}
newItem->setColor(static_cast<ColorRGB>(color));
}
else if (tagName == QLatin1String("color"))
{
if (!newItem)
{
LogPrintf(LogSeverityLevel::Warning, "Malformed favorites GPX file: unexpected <hidden/>");
return false;
}
newItem->setIsHidden(true);
}
}
else if (xmlReader.isEndElement())
{
if (tagName == QLatin1String("wpt"))
{
if (!newItem)
{
LogPrintf(LogSeverityLevel::Warning, "Malformed favorites GPX file: unpaired </wpt>");
return false;
}
newItems.push_back(newItem);
newItem.reset();
}
}
}
if (xmlReader.hasError())
{
LogPrintf(
LogSeverityLevel::Warning,
"XML error: %s (%" PRIi64 ", %" PRIi64 ")",
qPrintable(xmlReader.errorString()),
xmlReader.lineNumber(),
xmlReader.columnNumber());
return false;
}
{
QWriteLocker scopedLocker(&_collectionLock);
doClearFavoriteLocations();
appendFrom(newItems);
notifyCollectionChanged();
}
return true;
}
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 Syntax::load(QString file)
{
if(xmlSyntaxFileName==file)
return true;
else xmlSyntaxFileName=file;
printf("[Syntax::load] Loading syntax\n");
QXmlStreamReader xml;
QStack <QString> stack;
QFile fileDevice(file);
if (!fileDevice.open(QFile::ReadOnly | QFile::Text)) {
printf("Error al abrir el archivo\n");
return false;
}
highlightingRules.clear();
highlightingBlockRules.clear();
highlightingBracketsRules.clear();
xml.setDevice(&fileDevice);
QMap <QString,QString> values;
QVector<QString> xmlMainItems;
xmlMainItems << "item" << "block" << "bracket";
int ruleOrder=0;
while (!xml.atEnd())
{
QXmlStreamReader::TokenType tokenType=xml.readNext();
switch(tokenType)
{
case QXmlStreamReader::StartElement:
if(xml.name()!="syntax")
{
if( xmlMainItems.contains(xml.name().toString()) )
stack.push(xml.name().toString());
else
values[xml.name().toString()]=xml.readElementText().trimmed();
}
break;
case QXmlStreamReader::EndElement:
if(stack.isEmpty()) break;
QString name=stack.top();
if(name==xml.name()) stack.pop();
if(stack.isEmpty())
{
QTextCharFormat format;
if(values.contains("bold") && values["bold"]=="true") format.setFontWeight(QFont::Bold);
if(values.contains("underline") && values["underline"]=="true") format.setFontUnderline(true);
if(values.contains("italic") && values["italic"]=="true") format.setFontItalic(true);
if(values.contains("foreground")) format.setForeground(QBrush(QColor(values["foreground"])));
if(values.contains("background")) format.setBackground(QBrush(QColor(values["background"])));
if(name=="item")
{
HighlightingRule rule;
rule.format=format;
rule.pattern=QRegExp(values["pattern"]);
rule.ruleOrder=ruleOrder++;
highlightingRules.append(rule);
values.clear();
}
else if(name=="block" || name=="bracket")
{
HighlightingBlockRule rule;
rule.format=format;
rule.startPattern=QRegExp(values["startPattern"]);
rule.endPattern=QRegExp(values["endPattern"]);
rule.ruleOrder=ruleOrder++;
if(name=="block") highlightingBlockRules.append(rule);
else highlightingBracketsRules.append(rule); //Bracket rule
values.clear();
}
}
break;
}
}
if (xml.hasError())
{
// do error handling
printf("Error %s: %ld:%ld %s\n", file.toLocal8Bit().data(), xml.lineNumber(), xml.columnNumber(), xml.errorString().toLocal8Bit().data() );
return false;
}
return true;
}
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;
}
RunData::RunData(QObject *parent, QXmlStreamReader& reader):
QObject(parent)
{
init();
ID=reader.attributes().value("ID").toString().toInt();
while(reader.readNextStartElement())
{
if(reader.name()=="round")
{
round=reader.readElementText().toInt();
}
else if(reader.name()=="boatID")
{
boatID=reader.readElementText().toInt();
}
else if(reader.name()=="color")
{
color=reader.readElementText();
}
else if(reader.name()=="title1")
{
title1=reader.readElementText();
}
else if(reader.name()=="firstName1")
{
firstName1=reader.readElementText();
}
else if(reader.name()=="lastName1")
{
lastName1=reader.readElementText();
}
else if(reader.name()=="title2")
{
title2=reader.readElementText();
}
else if(reader.name()=="firstName2")
{
firstName2=reader.readElementText();
}
else if(reader.name()=="lastName2")
{
lastName2=reader.readElementText();
}
else if(reader.name()=="startTimeID")
{
startTimeID=reader.readElementText().toInt();
}
else if(reader.name()=="goalTimeID")
{
goalTimeID=reader.readElementText().toInt();
}
else if(reader.name()=="dsq")
{
dsq=reader.readElementText()=="true"?true:false;
}
else if(reader.name()=="errors")
{
errors=reader.readElementText();
}
else if(reader.name()=="published")
{
// ignore the published flag, it defaults to false
//published=reader.readElementText()=="true"?true:false;
reader.readElementText();
published=false;
}
else if(reader.name()=="notes")
{
notes=reader.readElementText();
}
else if(reader.name()=="fireBrigade")
{
fireBrigade=reader.readElementText();
}
else if(reader.name()=="valuationClass")
{
valuationClass=reader.readElementText();
}
else if(reader.name()=="agePoints")
{
agePoints=reader.readElementText();
}
else
{
reader.raiseError(tr("unbekanntes XML-Tag innerhalb von 'run', Zeile: ") + QString::number(reader.lineNumber()));
}
}
if(ID==0)
{
reader.raiseError(tr("Lauf hat ungültige ID!"));
}
}
