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 KeeAgentSettings::fromXml(const QByteArray& ba)
{
QXmlStreamReader reader;
reader.addData(ba);
if (reader.error() || !reader.readNextStartElement()) {
return false;
}
if (reader.qualifiedName() != "EntrySettings") {
return false;
}
while (!reader.error() && reader.readNextStartElement()) {
if (reader.name() == "AllowUseOfSshKey") {
m_allowUseOfSshKey = readBool(reader);
} else if (reader.name() == "AddAtDatabaseOpen") {
m_addAtDatabaseOpen = readBool(reader);
} else if (reader.name() == "RemoveAtDatabaseClose") {
m_removeAtDatabaseClose = readBool(reader);
} else if (reader.name() == "UseConfirmConstraintWhenAdding") {
m_useConfirmConstraintWhenAdding = readBool(reader);
} else if (reader.name() == "UseLifetimeConstraintWhenAdding") {
m_useLifetimeConstraintWhenAdding = readBool(reader);
} else if (reader.name() == "LifetimeConstraintDuration") {
m_lifetimeConstraintDuration = readInt(reader);
} else if (reader.name() == "Location") {
while (!reader.error() && reader.readNextStartElement()) {
if (reader.name() == "SelectedType") {
reader.readNext();
m_selectedType = reader.text().toString();
reader.readNext();
} else if (reader.name() == "AttachmentName") {
reader.readNext();
m_attachmentName = reader.text().toString();
reader.readNext();
} else if (reader.name() == "SaveAttachmentToTempFile") {
m_saveAttachmentToTempFile = readBool(reader);
} else if (reader.name() == "FileName") {
reader.readNext();
m_fileName = reader.text().toString();
reader.readNext();
} else {
qWarning() << "Skipping location element" << reader.name();
reader.skipCurrentElement();
}
}
} else {
qWarning() << "Skipping element" << reader.name();
reader.skipCurrentElement();
}
}
return true;
}
bool WeatherWidgetXMLEngine::getLocationDetails(const QString& aXMLData,
QList<LocationInfoT>& aLocationInfo)
{
qDebug()<<"WeatherWidgetXMLEngine::getLocationDetails->";
qDebug()<<aXMLData;
bool isfound = false;
QXmlStreamReader xml;
xml.addData(aXMLData);
while(!xml.atEnd())
{
if(QXmlStreamReader::NoError != xml.error())
{
// unable to get exact error code :(
int err = xml.error();
return false;
}
xml.readNext();
if(xml.isStartElement())
{
qDebug()<<"element: "<<xml.name().toString().toLower();
// location element
if(KElementLocation == xml.name().toString().toLower())
{
qDebug()<<xml.name().toString().toLower();
LocationInfoT locationinfo;
locationinfo.iCityCode = xml.attributes().value(KAttributeCityCode).toString();
locationinfo.iCityName = xml.attributes().value(KAttributeCityName).toString();
locationinfo.iCountryName = xml.attributes().value(KAttributeCountryName).toString();
locationinfo.iStateName = xml.attributes().value(KAttributeStateName).toString();
locationinfo.iZipCode = xml.attributes().value(KAttributeZipCode).toString();
isfound = true;
aLocationInfo.append(locationinfo);
} // location element
}// new element
} // while
qDebug()<<"found locations: "<<aLocationInfo.count();
qDebug()<<"WeatherWidgetXMLEngine::getLocationDetails<-";
return isfound;
}
void APIController::getAnimeID(QString name)
{
QFile f("C:/reports.xml");
QXmlStreamReader reader;
f.open(QIODevice::ReadOnly);
reader.setDevice(&f);
int aid;
while (!reader.atEnd()) {
reader.readNext();
if (reader.name() == "id" && reader.tokenString()=="StartElement") {
reader.readNext();
aid = reader.text().toInt();
}
if (reader.text().toString().toUpper() == name.toUpper())
{
path="C:/"+QString::number(aid);
file = new QFile(path);
file->open(QIODevice::ReadWrite);
url.setUrl("http://cdn.animenewsnetwork.com/encyclopedia/api.xml?anime="+QString::number(aid));
reply = qnam.get(QNetworkRequest(url));
QObject::connect(reply, SIGNAL(readyRead()),
this, SLOT(httpReadyRead()));
QObject::connect(reply, SIGNAL(finished()),
this, SLOT(httpFinished()));
qDebug()<<QString::number(aid);
return;
}
}
if (reader.hasError()) {
qDebug()<<reader.error();
}
}
bool ewsXmlEnumReader(QXmlStreamReader &reader, QVariant &val, QVector<QString> items)
{
QString elmName = reader.name().toString();
QString text = reader.readElementText();
if (reader.error() != QXmlStreamReader::NoError) {
qCWarningNC(EWSRES_LOG) << QStringLiteral("Failed to read %1 element - invalid content.")
.arg(elmName);
reader.skipCurrentElement();
return false;
}
int i;
QVector<QString>::const_iterator it;
for (it = items.cbegin(); it != items.cend(); it++, i++) {
if (text == *it) {
val = i;
break;
}
}
if (it == items.cend()) {
qCWarningNC(EWSRES_LOG) << QStringLiteral("Failed to read %1 element - unknown value %2.")
.arg(elmName).arg(text);
return false;
}
return true;
}
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;
}
}
// 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);
}
bool ewsXmlDateTimeReader(QXmlStreamReader &reader, QVariant &val)
{
QString elmName = reader.name().toString();
QDateTime dt = QDateTime::fromString(reader.readElementText(), Qt::ISODate);
if (reader.error() != QXmlStreamReader::NoError || !dt.isValid()) {
qCWarningNC(EWSRES_LOG) << QStringLiteral("Failed to read %1 element - invalid content.")
.arg(elmName);
return false;
}
val = QVariant::fromValue<QDateTime>(dt);
return true;
}
bool ewsXmlUIntReader(QXmlStreamReader &reader, QVariant &val)
{
QString elmName = reader.name().toString();
bool ok;
val = reader.readElementText().toUInt(&ok);
if (reader.error() != QXmlStreamReader::NoError || !ok) {
qCWarningNC(EWSRES_LOG) << QStringLiteral("Failed to read %1 element - invalid content.")
.arg(elmName);
return false;
}
return true;
}
void DataFetcher::parseProjectHealth(QXmlStreamReader &xml)
{
while (!(xml.error() || xml.atEnd() || endOfElement("healthReport",xml)))
{
if (xml.readNextStartElement()) {
if (xml.name() == "score")
currentProject.healthInPercent = xml.readElementText().toInt();
else
xml.skipCurrentElement();
}
}
}
bool ewsXmlBase64Reader(QXmlStreamReader &reader, QVariant &val)
{
QString elmName = reader.name().toString();
val = KCodecs::base64Decode(reader.readElementText().toLatin1());
if (reader.error() != QXmlStreamReader::NoError) {
qCWarningNC(EWSRES_LOG) << QStringLiteral("Failed to read %1 element - invalid content.")
.arg(elmName);
reader.skipCurrentElement();
return false;
}
return true;
}
void DataFetcher::parseLastBuild(QXmlStreamReader &xml)
{
while (!(xml.error() || xml.atEnd() || endOfElement("lastBuild",xml)))
{
if (xml.readNextStartElement()) {
if (xml.name() == "userName")
currentProject.lastBuildUsername = xml.readElementText();
if (xml.name() == "timestamp") {
qulonglong timestamp= ((qulonglong)xml.readElementText().toULongLong());
currentProject.date = QDateTime::fromMSecsSinceEpoch( timestamp ).toString(Qt::SystemLocaleLongDate);
}
if (xml.name() == "result")
currentProject.lastBuildOK = xml.readElementText() == "SUCCESS";
}
}
}
std::vector<ViewData> SessionReader::readData(bool* outSuccess) {
std::vector<ViewData> result;
if (m_reader.readNextStartElement()) {
if (m_reader.name() == "Notepadqq") {
result = readViewData();
}
else
m_reader.raiseError(QObject::tr("Error reading session file"));
};
if (outSuccess != nullptr)
*outSuccess = !m_reader.error();
return result;
}
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;
}
void DataFetcher::parseJob(QXmlStreamReader &xml)
{
currentProject.clear();
while (!(xml.error() || xml.atEnd() || endOfElement("job",xml)))
{
if (xml.readNextStartElement())
{
if (xml.name() == "name")
currentProject.name = xml.readElementText();
else if (xml.name() == "url")
currentProject.link = xml.readElementText();
else if (xml.name() == "color")
currentProject.color = xml.readElementText();
else if (xml.name() == "healthReport")
parseProjectHealth(xml);
else if (xml.name() == "lastBuild")
parseLastBuild(xml);
else
xml.skipCurrentElement();
}
}
emit projectItemReady(currentProject);
}
EwsAttendee::EwsAttendee(QXmlStreamReader &reader)
: d(new EwsAttendeePrivate())
{
while (reader.readNextStartElement()) {
if (reader.namespaceUri() != ewsTypeNsUri) {
qCWarningNC(EWSRES_LOG) << QStringLiteral("Unexpected namespace in mailbox element:")
<< reader.namespaceUri();
return;
}
if (reader.name() == QStringLiteral("Mailbox")) {
d->mMailbox = EwsMailbox(reader);
if (!d->mMailbox.isValid()) {
qCWarning(EWSRES_LOG) << QStringLiteral("Failed to read EWS request - invalid attendee %1 element.")
.arg(reader.name().toString());
return;
}
}
else if (reader.name() == QStringLiteral("ResponseType")) {
bool ok;
d->mResponse = decodeEnumString<EwsEventResponseType>(reader.readElementText(),
responseTypeNames, responseTypeNameCount, &ok);
if (reader.error() != QXmlStreamReader::NoError || !ok) {
qCWarning(EWSRES_LOG) << QStringLiteral("Failed to read EWS request - invalid attendee %1 element.")
.arg(reader.name().toString());
return;
}
}
else if (reader.name() == QStringLiteral("LastResponseTime")) {
// Unsupported - ignore
//qCWarningNC(EWSCLIENT_LOG) << QStringLiteral("Unsupported mailbox element %1").arg(reader.name().toString());
reader.skipCurrentElement();
}
}
d->mValid = true;
}
bool ewsXmlBoolReader(QXmlStreamReader &reader, QVariant &val)
{
QString elmText = reader.readElementText();
if (reader.error() != QXmlStreamReader::NoError) {
qCWarningNC(EWSRES_LOG) << QStringLiteral("Error reading %1 element")
.arg(reader.name().toString());
reader.skipCurrentElement();
return false;
}
if (elmText == QStringLiteral("true")) {
val = true;
}
else if (elmText == QStringLiteral("false")) {
val = false;
}
else {
qCWarningNC(EWSRES_LOG) << QStringLiteral("Unexpected invalid boolean value in %1 element:")
.arg(reader.name().toString())
<< elmText;
return false;
}
return true;
}
/**
* @brief Record the details of an XML parse error.
*
* If \a xml has no error, this effectively clears any existing XML parsing
* error.
*
* @param xml XML reader from which to fetch an parse error code and string.
*
* @see xmlParseError
* @see xmlParseErrorString
*/
void AwsAbstractResponse::setXmlError(const QXmlStreamReader &xml)
{
Q_D(AwsAbstractResponse);
d->xmlError = xml.error();
d->xmlErrorString = xml.errorString();
}
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
}
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);
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;
}
void readUntilEndOf(QString elem, QXmlStreamReader &xml) {
while (!(xml.error() || xml.atEnd() || endOfElement("job",xml)))
xml.readNext();
}
bool
DirectParser::Read (DirectMessage & msg)
{
msg.Clear ();
if (!bufLock.tryLock (5000)) {
qDebug () << "WARNING: Mutex locked 5 seconds, giving up";
return false;
}
QXmlStreamReader xread (&inbuf);
QXmlStreamReader::TokenType tokt;
bool finished (false);
bool complete (false);
bool good (false);
bool badData (false);
QString topname;
QString bottomtag;
QString version;
qint64 offset (0);
while (!finished) {
tokt = ReadNext (xread);
offset = xread.characterOffset ();
qDebug () << " Direct token " << xread.tokenString();
switch (tokt) {
case QXmlStreamReader::NoToken :
qDebug () << " no token found";
finished = true; complete = false; good = false;
lastErr = Proto_EmptyInput;
break;
case QXmlStreamReader::Invalid :
qDebug () << " bad token";
qDebug () << " text until here: " << inbuf.buffer().left(offset);
finished = true; complete = false; good = false;
lastErr = Proto_BadTag;
badData = true;
break;
case QXmlStreamReader::StartElement:
topname = xread.name().toString().toLower();
if (topname == oldTopTag) {
ParseOld (xread, msg, offset, complete, good);
msg.SetAttribute ("version","0.1");
} else if (topname == topTag) {
version = xread.documentVersion ().toString();
msg.SetAttribute ("version",version);
ParseMessage (xread, msg, offset, complete, good);
} else {
qDebug () << " topname unknown: " << topname;
finished = true; complete = false; good = false;
lastErr = Proto_WrongProtocol;
}
break;
case QXmlStreamReader::EndElement:
bottomtag = xread.name().toString().toLower();
if (bottomtag == topname) {
finished = true;
}
break;
case QXmlStreamReader::EndDocument :
finished = true;
break;
case QXmlStreamReader::Characters:
break;
case QXmlStreamReader::StartDocument:
case QXmlStreamReader::Comment:
case QXmlStreamReader::DTD:
case QXmlStreamReader::EntityReference:
case QXmlStreamReader::ProcessingInstruction:
break;
default:
qDebug () << " unknown token type " << tokt;
lastErr = Proto_Unknown;
finished = true; complete = false; good = false;
break;
}
}
if (good && complete) {
/// we have consumed a message, so get rid of the raw data
/// so we can read the next message next time
qDebug () << " trailing token " << xread.tokenString ();
while (!xread.atEnd() && xread.tokenType() != QXmlStreamReader::EndDocument) {
xread.readNext();
qDebug () << " consumed " << xread.tokenString ();
}
qDebug () << " remove " << offset << " bytes from buffer: ";
qDebug () << inbuf.buffer().left(offset);
inbuf.buffer().remove (0,offset+1);
inbuf.seek (0);
} else {
msg.Clear ();
}
qDebug () << " after DirectParser::Read buffer has [[" << inbuf.buffer() << "]]";
qDebug () << " token " << xread.tokenString() << " error " << xread.error();
if (!good) {
if (xread.error () == QXmlStreamReader::PrematureEndOfDocumentError) {
complete = false;
good = true;
}
}
lastComplete = complete;
lastGood = good;
bufLock.unlock ();
return good && complete;
}
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
};
}
}
