bool Import_Argo::loadFromArgoFile(const KZip &zipFile, const QString &fileName)
{
const KArchiveFile *file = static_cast<const KArchiveFile*>(zipFile.directory()->entry(fileName));
if (!file)
return false;
QXmlStreamReader xml;
xml.addData(file->data());
while (!xml.atEnd()) {
xml.readNext();
if (xml.name() == QLatin1String("member")) {
QXmlStreamAttributes attributes = xml.attributes();
QString type = attributes.value(QLatin1String("type")).toString();
QString name = attributes.value(QLatin1String("name")).toString();
if (type == QLatin1String("xmi"))
loadFromXMIFile(zipFile, name);
else if (type == QLatin1String("pgml"))
loadFromPGMLFile(zipFile, name);
else if (type == QLatin1String("todo"))
loadFromTodoFile(zipFile, name);
else
uError() << "unknown file type" << type << "in file" << zipFile.fileName() << ":" << fileName;
}
}
if (xml.hasError()) {
reportError(xml, zipFile, fileName);
return false;
}
return true;
}
void
CadHeaderHandler::run(QXmlStreamReader& xml)
{
m_units = getUnitAttribute(xml, "CadHeader", "units");
while (!xml.atEnd() && !xml.hasError()) {
xml.readNext();
if (xml.isStartElement()) {
if (xml.name() == "Spec") {
// TODO skipped
//throw new NonImplementedError("CadHeader::Spec");
}
else if (xml.name() == "SurfaceFinish") {
// TODO skipped
//throw new NonImplementedError("CadHeader::SurfaceFinish");
}
else if (xml.name() == "ChangeRec") {
// TODO skipped
//throw new NonImplementedError("CadHeader::ChangeRec");
}
}
else if (isEndElementWithName(xml, "CadHeader")) { // </CadHeader>
return;
}
}
}
void
Target::initialize(QXmlStreamReader& xml, UnitsType units)
{
m_xform = NULL;
while (!xml.atEnd() && !xml.hasError()) {
xml.readNext();
if (xml.isStartElement()) {
if (xml.name() == "Xform") {
m_xform = new Xform();
m_xform->initialize(xml);
}
else if (xml.name() == "Location") {
m_location = QPointF(getDoubleAttribute(xml, "Location", "x"),
getDoubleAttribute(xml, "Location", "y"));
}
else if (isSubstitutionGroupStandardShape(xml.name())) {
m_standardShape = StandardShapeFactory().create(xml.name());
m_standardShape->initialize(xml, units);
}
}
else if (isEndElementWithName(xml, "Target")) { // </Target>
return;
}
}
}
void
StackupLayer::initialize(QXmlStreamReader& xml)
{
m_layerOrGroupRef =
getStringAttribute(xml, "StackupLayer", "layerOrGroupRef");
m_materialType = getStringAttribute(xml, "StackupLayer", "materialType");
m_thickness = getNonNegativeDoubleAttribute(xml, "StackupLayer", "thickness");
if (hasAttribute(xml, "weight")) {
m_weight = getNonNegativeDoubleAttribute(xml, "StackupLayer", "weight");
}
if (hasAttribute(xml, "coating")) {
m_coating = getStringAttribute(xml, "StackupLayer", "coating");
}
if (hasAttribute(xml, "comment")) {
m_comment = getStringAttribute(xml, "StackupLayer", "comment");
}
while (!xml.atEnd() && !xml.hasError()) {
xml.readNext();
if (xml.isStartElement()) {
if (isSubstitutionGroupAttribute(xml.name())) {
Attribute *a = AttributeFactory().create(xml.name());
a->initialize(xml);
m_attributes.append(a);
}
}
else if (isEndElementWithName(xml, "StackupLayer")) { // </StackupLayer>
return;
}
}
}
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;
}
}
void
DictionaryUserHandler::run(QXmlStreamReader& xml)
{
m_units = getUnitAttribute(xml, "DictionaryUser", "units");
while (!xml.atEnd() && !xml.hasError()) {
xml.readNext();
if (xml.isStartElement()) {
if (xml.name() == "EntryUser") {
QString id = getStringAttribute(xml, "EntryUser", "id");
// id must be unique
if (g_entryUsers.contains(id)) {
throw new DuplicateIdError("EntryUser", id);
}
// create element and insert to hash table
xml.readNextStartElement(); // <Simple>, <Text>, <UserSpecial>
UserPrimitive* u = UserPrimitiveFactory().create(xml.name());
u->initialize(xml, m_units);
g_entryUsers.insert(id, u);
}
}
else if (isEndElementWithName(xml, "DictionaryUser")) {
break;
}
}
}
DataObjectPtr EventMonitorFactory::generateObject(ObjectStore *store, QXmlStreamReader& xml) {
Q_ASSERT(store);
QString equation, description, emailRecipients, script;
bool logDebug=false, logEmail=false, logELOG=false;
int logLevel=1;
while (!xml.atEnd()) {
const QString n = xml.name().toString();
if (xml.isStartElement()) {
if (n == EventMonitorEntry::staticTypeTag) {
QXmlStreamAttributes attrs = xml.attributes();
equation = attrs.value("equation").toString();
description = attrs.value("description").toString();
emailRecipients = attrs.value("emailrecipients").toString();
script = attrs.value("script").toString();
logLevel = attrs.value("loglevel").toString().toInt();
logDebug = attrs.value("logdebug").toString() == "true" ? true : false;
logEmail = attrs.value("logemail").toString() == "true" ? true : false;
logELOG = attrs.value("logelog").toString() == "true" ? true : false;
} else {
return 0;
}
} else if (xml.isEndElement()) {
if (n == EventMonitorEntry::staticTypeTag) {
break;
} else {
Debug::self()->log(QObject::tr("Error creating EventMonitorEntry from Kst file."), Debug::Warning);
return 0;
}
}
xml.readNext();
}
if (xml.hasError()) {
return 0;
}
EventMonitorEntryPtr eventMonitor = store->createObject<EventMonitorEntry>();
Q_ASSERT(eventMonitor);
eventMonitor->setScriptCode(script);
eventMonitor->setEvent(equation);
eventMonitor->setDescription(description);
eventMonitor->setLevel((Debug::LogLevel)logLevel);
eventMonitor->setLogDebug(logDebug);
eventMonitor->setLogEMail(logEmail);
eventMonitor->setLogELOG(logELOG);
eventMonitor->setEMailRecipients(emailRecipients);
eventMonitor->reparse();
eventMonitor->writeLock();
eventMonitor->registerChange();
eventMonitor->unlock();
return eventMonitor;
}
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;
}
PrimitivePtr EditableMatrixFactory::generatePrimitive(ObjectStore *store, QXmlStreamReader& xml) {
QByteArray data;
QString descriptiveName;
Q_ASSERT(store);
double minX=0, minY=0, nX=10, nY=10, stepX=1, stepY=1;
while (!xml.atEnd()) {
const QString n = xml.name().toString();
if (xml.isStartElement()) {
if (n == EditableMatrix::staticTypeTag) {
QXmlStreamAttributes attrs = xml.attributes();
minX = attrs.value("xmin").toString().toDouble();
minY = attrs.value("ymin").toString().toDouble();
nX = attrs.value("nx").toString().toDouble();
nY = attrs.value("ny").toString().toDouble();
stepX = attrs.value("xstep").toString().toDouble();
stepY = attrs.value("ystep").toString().toDouble();
if (attrs.value("descriptiveNameIsManual").toString() == "true") {
descriptiveName = attrs.value("descriptiveName").toString();
}
Object::processShortNameIndexAttributes(attrs);
} else if (n == "data") {
QString qcs(xml.readElementText().toLatin1());
QByteArray qbca = QByteArray::fromBase64(qcs.toLatin1());
data = qUncompress(qbca);
} else {
return 0;
}
} else if (xml.isEndElement()) {
if (n == EditableMatrix::staticTypeTag) {
break;
} else {
Debug::self()->log(QObject::tr("Error creating Editable Matrix from Kst file."), Debug::Warning);
return 0;
}
}
xml.readNext();
}
if (xml.hasError()) {
return 0;
}
EditableMatrixPtr matrix = store->createObject<EditableMatrix>();
matrix->change(data, uint(nX), uint(nY), minX, minY, stepX, stepY);
matrix->setDescriptiveName(descriptiveName);
matrix->writeLock();
matrix->registerChange();
matrix->unlock();
return matrix;
}
bool DMARC::SPFAuthenticationResultPrivate::parse(QXmlStreamReader& r)
{
bool seen_domain = false;
bool seen_result = false;
while (r.readNextStartElement()) {
if (r.name() == QLatin1String("domain")) {
if (!seen_domain) {
seen_domain = true;
this->domain = r.readElementText();
}
else {
r.raiseError(QCoreApplication::translate("dmarcparser", "Duplicate <%1> tag").arg(QLatin1String("domain")));
}
}
else if (r.name() == QLatin1String("result")) {
if (!seen_result) {
QString value = r.readElementText();
seen_result = true;
this->result = string2spfauthres(value);
if (DMARC::SpfUnknown == this->result) {
r.raiseError(QCoreApplication::translate("dmarcparser", "Value '%1' is not valid for <%2>").arg(value, QLatin1String("result")));
}
}
else {
r.raiseError(QCoreApplication::translate("dmarcparser", "Duplicate <%1> tag").arg(QLatin1String("result")));
}
}
else {
r.raiseError(QCoreApplication::translate("dmarcparser", "Unexpected element <%1>").arg(r.name().toString()));
}
}
if (!r.hasError()) {
if (!seen_domain) {
r.raiseError(QCoreApplication::translate("dmarcparser", "No <%1> tag").arg(QLatin1String("domain")));
}
else if (!seen_result) {
r.raiseError(QCoreApplication::translate("dmarcparser", "No <%1> tag").arg(QLatin1String("result")));
}
}
return !r.hasError();
}
PrimitivePtr GeneratedMatrixFactory::generatePrimitive(ObjectStore *store, QXmlStreamReader& xml) {
QByteArray data;
QString descriptiveName;
Q_ASSERT(store);
bool xDirection=1;
double gradZMin=-1, gradZMax=1, minX=0, minY=0, nX=10, nY=10, stepX=1, stepY=1;
while (!xml.atEnd()) {
const QString n = xml.name().toString();
if (xml.isStartElement()) {
if (n == GeneratedMatrix::staticTypeTag) {
QXmlStreamAttributes attrs = xml.attributes();
gradZMin = attrs.value("gradzmin").toString().toDouble();
gradZMax = attrs.value("gradzmax").toString().toDouble();
minX = attrs.value("xmin").toString().toDouble();
minY = attrs.value("ymin").toString().toDouble();
nX = attrs.value("nx").toString().toDouble();
nY = attrs.value("ny").toString().toDouble();
stepX = attrs.value("xstep").toString().toDouble();
stepY = attrs.value("ystep").toString().toDouble();
xDirection = attrs.value("xdirection").toString() == "true" ? true : false;
if (attrs.value("descriptiveNameIsManual").toString() == "true") {
descriptiveName = attrs.value("descriptiveName").toString();
}
Object::processShortNameIndexAttributes(attrs);
} else {
return 0;
}
} else if (xml.isEndElement()) {
if (n == GeneratedMatrix::staticTypeTag) {
break;
} else {
Debug::self()->log(QObject::tr("Error creating Generated Matrix from Kst file."), Debug::Warning);
return 0;
}
}
xml.readNext();
}
if (xml.hasError()) {
return 0;
}
GeneratedMatrixPtr matrix = store->createObject<GeneratedMatrix>();
matrix->change(uint(nX), uint(nY), minX, minY, stepX, stepY, gradZMin, gradZMax, xDirection);
matrix->setDescriptiveName(descriptiveName);
matrix->writeLock();
matrix->registerChange();
matrix->unlock();
return matrix;
}
void CWidgetPropParser::parseGUIWidgetProperties( QXmlStreamReader &reader, const QString &widgetName )
{
reader.readNext();
if( reader.atEnd() )
return;
std::map< std::string, SWidgetInfo >::iterator itr =
widgetInfo->find( widgetName.toUtf8().constData() );
if( itr == widgetInfo->end() )
return;
std::vector< SPropEntry > &v = itr->second.props;
while( !reader.atEnd() && !( reader.isEndElement() && ( reader.name() == "properties" ) ) )
{
if( reader.isStartElement() && reader.name() == "property" )
{
SPropEntry prop;
reader.readNext();
while( !reader.atEnd() && !( reader.isEndElement() && ( reader.name() == "property" ) ) )
{
if( reader.isStartElement() )
{
QString key = reader.name().toString();
QString value = reader.readElementText( QXmlStreamReader::ErrorOnUnexpectedElement );
if( !reader.hasError() )
{
if( key == "name" )
prop.propName = value.toUtf8().constData();
else
if( key == "type" )
prop.propType = value.toUtf8().constData();
else
if( key == "default" )
prop.propDefault = value.toUtf8().constData();
else
nlwarning( QString( "Unknown tag %1 within a property" ).arg( key ).toUtf8().constData() );
}
else
nlwarning( "Malformed XML." );
}
reader.readNext();
}
if( reader.atEnd() )
return;
v.push_back( prop );
}
reader.readNext();
}
}
void
BomHandler::run(QXmlStreamReader& xml)
{
while (!xml.atEnd() && !xml.hasError()) {
xml.readNext();
if (isEndElementWithName(xml, "Bom")) {
return;
}
}
}
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_id("id");
static const QLatin1String attribute_featuresRequired("featuresRequired");
static const QLatin1String attribute_openEditor("openeditor");
static const QLatin1String attribute_priority("priority");
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().toInt();
if (reader.attributes().hasAttribute(attribute_id))
info->wizardId = reader.attributes().value(attribute_id).toString();
if (reader.attributes().hasAttribute(attribute_featuresRequired))
info->featuresRequired = reader.attributes().value(attribute_featuresRequired).toString();
} 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;
}
bool DMARC::OverrideReasonPrivate::parse(QXmlStreamReader& r)
{
bool seen_type = false;
bool seen_comment = false;
while (r.readNextStartElement()) {
if (r.name() == QLatin1String("type")) {
if (!seen_type) {
QString val = r.readElementText();
seen_type = true;
this->type = string2ot(val);
if (DMARC::OverrideUnknown == this->type) {
r.raiseError(QCoreApplication::translate("dmarcparser", "Value '%1' is not valid for <%2>").arg(val, QLatin1String("type")));
}
}
else {
r.raiseError(QCoreApplication::translate("dmarcparser", "Duplicate <%1> tag").arg(QLatin1String("type")));
}
}
else if (r.name() == QLatin1String("comment")) {
if (!seen_comment) {
seen_comment = true;
this->comment = r.readElementText();
}
else {
r.raiseError(QCoreApplication::translate("dmarcparser", "Duplicate <%1> tag").arg(QLatin1String("comment")));
}
}
else {
r.raiseError(QCoreApplication::translate("dmarcparser", "Unexpected element <%1>").arg(r.name().toString()));
}
}
if (!r.hasError()) {
if (!seen_type) {
r.raiseError(QCoreApplication::translate("dmarcparser", "No <%1> tag").arg(QLatin1String("type")));
}
}
return !r.hasError();
}
/** Skips to the end tag of an unknown element, ignoring any nested elements. */
void PwStreamUtilsV4::readUnknown(QXmlStreamReader& xml) {
QStringRef unknownTagName = xml.name();
LOG("WARN: unknown XML element: %s", unknownTagName.toUtf8().constData());
while (!xml.hasError() && !(xml.isEndElement() && (xml.name() == unknownTagName))) {
xml.readNext();
if (xml.isStartElement()) {
readUnknown(xml);
}
}
}
// 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);
}
QString CWidgetPropParser::parseGUIWidgetHeader( QXmlStreamReader &reader )
{
reader.readNext();
if( reader.atEnd() )
return QString( "" );
SWidgetInfo info;
while( !reader.atEnd() && !( reader.isEndElement() && ( reader.name() == "header" ) ) )
{
if( reader.isStartElement() )
{
QString key = reader.name().toString();
QString value = reader.readElementText( QXmlStreamReader::ErrorOnUnexpectedElement );
if( !reader.hasError() )
{
if( key == "name" )
info.name = value.toUtf8().constData();
else
if( key == "guiname" )
info.GUIName = value.toUtf8().constData();
else
if( key == "ancestor" )
info.ancestor = value.toUtf8().constData();
else
if( key == "description" )
info.description = value.toUtf8().constData();
else
if( key == "icon" )
info.icon == value.toUtf8().constData();
else
if( key == "abstract" )
{
info.isAbstract = false;
if( value == "true" )
info.isAbstract = true;
}
else
nlwarning( "Malformed XML." );
}
}
reader.readNext();
}
if( reader.atEnd() )
return QString( "" );
if( info.name.empty() )
return QString( "" );
(*widgetInfo)[ info.name.c_str() ] = info;
return QString( info.name.c_str() );
}
// Read all current Ranges controls from an XML stream
bool US_RunProtocol::RunProtoRanges::fromXml( QXmlStreamReader& xmli )
{
nranges = 0;
chrngs.clear();
Ranges rng;
while( ! xmli.atEnd() )
{
QString ename = xmli.name().toString();
if ( xmli.isStartElement() )
{
if ( ename == "range" || ename == "spectrum" )
{
QXmlStreamAttributes attr = xmli.attributes();
rng.channel = attr.value( "channel" ) .toString();
QString slorad = attr.value( "start_radius" ).toString();
QString shirad = attr.value( "end_radius" ) .toString();
rng.lo_rad = slorad.isEmpty() ? rng.lo_rad : slorad.toDouble();
rng.hi_rad = shirad.isEmpty() ? rng.hi_rad : shirad.toDouble();
rng.wvlens.clear();
}
else if ( ename == "wavelength" || ename == "point" )
{
QXmlStreamAttributes attr = xmli.attributes();
rng.wvlens << attr.value( "lambda" ).toString().toDouble();
}
}
else if ( xmli.isEndElement() &&
( ename == "range" || ename == "spectrum" ) )
{
chrngs << rng;
nranges++;
}
bool was_end = xmli.isEndElement(); // Just read was End of element?
xmli.readNext(); // Read the next element
if ( was_end )
{
if ( ename == "ranges" || // Break after "</ranges>"
ename == "spectra" ) // Break after "</spectra>"
break;
}
}
return ( ! xmli.hasError() );
}
std::tuple<bool, const char*> loadWordStatisticsXml(const std::wstring& filePath, WordsUsageInfo& wordsStat, std::vector<const WordSeqUsage*>& wordSeqOrder)
{
QFile file(QString::fromStdWString(filePath));
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
return std::make_tuple(false, "Can't open file");
QXmlStreamReader xml;
xml.setDevice(&file);
// got to document root
xml.readNextStartElement(); // document root
//
while (!xml.atEnd())
{
xml.readNext();
if (xml.isStartElement() && xml.name() == "word")
{
QXmlStreamAttributes attrs = xml.attributes();
QStringRef idRef = attrs.value("id");
bool parseNum;
int usedCount = attrs.value("usedCount").toInt(&parseNum);
if (!parseNum)
return std::make_tuple(false, "usedCount must be integer");
QString wordQ = QString::fromRawData(idRef.constData(), idRef.size());
std::wstring wordW((const wchar_t*)wordQ.utf16(), wordQ.size());
bool wasAdded = false;
const WordPart* wordPart = wordsStat.getOrAddWordPart(wordW, WordPartSide::WholeWord, &wasAdded);
if (!wasAdded)
return std::make_tuple(false, "Error: duplicate words in words statistic");
WordSeqKey wordIds({ wordPart->id() });
WordSeqUsage* wordUsage = wordsStat.getOrAddWordSequence(wordIds, &wasAdded);
if (!wasAdded)
return std::make_tuple(false, "Error: duplicate words in words statistic");
wordUsage->UsedCount = usedCount;
wordSeqOrder.push_back(wordUsage);
}
}
if (xml.hasError())
return std::make_tuple(false, "Error in XML parsing");
return std::make_tuple(true, nullptr);
}
bool DMARC::RecordIdentifierPrivate::parse(QXmlStreamReader& r)
{
bool seen_envelope = false;
bool seen_from = false;
while (r.readNextStartElement()) {
if (r.name() == QLatin1String("envelope_to")) {
if (!seen_envelope) {
seen_envelope = true;
this->envelope_to = r.readElementText();
}
else {
r.raiseError(QCoreApplication::translate("dmarcparser", "Duplicate <%1> tag").arg(QLatin1String("envelope_to")));
}
}
else if (r.name() == QLatin1String("header_from")) {
if (!seen_from) {
seen_from = true;
this->header_from = r.readElementText();
}
else {
r.raiseError(QCoreApplication::translate("dmarcparser", "Duplicate <%1> tag").arg(QLatin1String("header_from")));
}
}
else {
r.raiseError(QCoreApplication::translate("dmarcparser", "Unexpected element <%1>").arg(r.name().toString()));
}
}
if (!r.hasError()) {
if (!seen_from) {
r.raiseError(QCoreApplication::translate("dmarcparser", "No <%1> tag").arg(QLatin1String("header_from")));
}
}
return !r.hasError();
}
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;
}
// Read all current Solutions controls from an XML stream
bool US_RunProtocol::RunProtoSolutions::fromXml( QXmlStreamReader& xmli )
{
nschan = 0;
chsols.clear();
while( ! xmli.atEnd() )
{ // Read elements from solution portion of XML stream
QString ename = xmli.name().toString();
if ( xmli.isStartElement() )
{
if ( ename == "solution" )
{ // Accumulate each solution object
ChanSolu cs;
QXmlStreamAttributes attr = xmli.attributes();
cs.channel = attr.value( "channel" ).toString();
cs.solution = attr.value( "name" ).toString();
cs.sol_id = attr.value( "id" ).toString();
cs.ch_comment = attr.value( "chan_comment" ).toString();
chsols << cs;
nschan++;
}
}
bool was_end = xmli.isEndElement(); // Just read was End of element?
xmli.readNext(); // Read the next element
if ( was_end && ename == "solutions" ) // Break after "</solutions>"
break;
}
// Build unique solutions list, with corresponding solution IDs
nuniqs = 0;
solus.clear();
sids .clear();
for ( int ii = 0; ii < nschan; ii++ )
{
QString sdesc = chsols[ ii ].solution;
if ( ! solus.contains( sdesc ) )
{ // Update unique solutions list and correspond Id list
solus << sdesc;
sids << chsols[ ii ].sol_id;
nuniqs++;
}
}
return ( ! xmli.hasError() );
}
PaSettings::PaSettings(QWidget *parent) :
QDialog(parent),
ui(new Ui::PaSettings)
{
ui->setupUi(this);
connect(this,SIGNAL(accepted()),this,SLOT(apply()));
//load settings
QString dir = QDir::homePath()+"/.pa/settings.xml";
qDebug()<<dir;
settingsFile = new QFile(dir);
if(settingsFile->open(QIODevice::ReadOnly))
{
QXmlStreamReader read;
read.setDevice(settingsFile);
while(!read.atEnd())
{
QXmlStreamReader::TokenType token = read.readNext();
if(token == QXmlStreamReader::StartDocument) {
continue;
}
if(token == QXmlStreamReader::StartElement) {
if(read.name() == "settings") {
continue;
}
if(read.name() == "beamerIP") {
beamerIP = read.readElementText();
continue;
}
}
}
if (read.hasError())
{
beamerIP = "127.0.0.1";
}
settingsFile->close();
}
else //not optimum
{
beamerIP = "127.0.0.1";
}
}
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;
}
void GModelComponent::readArgument(QXmlStreamReader &xmlReader , IModelComponent* component)
{
if(!xmlReader.name().compare("Argument", Qt::CaseInsensitive) && !xmlReader.hasError() && xmlReader.tokenType() == QXmlStreamReader::StartElement )
{
QXmlStreamAttributes attributes = xmlReader.attributes();
if(attributes.hasAttribute("Id") && attributes.hasAttribute("ArgumentIOType"))
{
QStringRef argumentId = attributes.value("Id");
QStringRef argIOType = attributes.value("ArgumentIOType");
IArgument* targument = nullptr;
for(IArgument* argument : component->arguments())
{
qDebug() << argument->id();
if(!argumentId.toString().compare(argument->id() , Qt::CaseInsensitive))
{
targument = argument;
QString value;
QXmlStreamWriter writer(&value);
while(!(xmlReader.isEndElement() && !xmlReader.name().compare("Argument", Qt::CaseInsensitive)) && !xmlReader.hasError())
{
xmlReader.readNext();
writer.writeCurrentToken(xmlReader);
qDebug() << xmlReader.text();
}
if(!argIOType.toString().compare("File", Qt::CaseInsensitive))
{
targument->readValues(value , true);
}
else
{
qDebug() << value;
targument->readValues(value);
}
break;
}
}
}
}
}
Var Var::fromXML(QXmlStreamReader& xml)
{
while (xml.tokenType() != QXmlStreamReader::StartElement && !xml.atEnd() && !xml.hasError())
{
xml.readNext();
}
QString root = xml.name().toString();
setParam("map",root);
while (!(xml.tokenType() == QXmlStreamReader::EndElement && xml.name() == root) && !xml.atEnd() && !xml.hasError())
{
xml.readNext();
if (xml.tokenType() == QXmlStreamReader::StartElement)
{
Var el;
el.fromXML(xml);
if(getType()=="map")
{
if(!Map.contains(el.getName()))
{
Map.insert(el.getName(),el);
}
else
{
setType("list");
List<<Map.value(el.getName());
}
}
if(getType()=="list")
{
List<<el;
}
}
if (xml.tokenType() == QXmlStreamReader::Characters)
{
QString text=xml.text().toString();
if(!text.startsWith('\n'))
{
setType("string");
String = text;
}
}
}
return *this;
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
qDebug()<< "jjdjjd";
QFile *file = new QFile("settings.xml");
if(!file->open(QIODevice::ReadWrite | QIODevice::Text)) {
qDebug() << "Could not open the XML File";
return -1;
}
QXmlStreamReader *reader = new QXmlStreamReader(file);
QXmlStreamWriter *writer = new QXmlStreamWriter(file);
while(!reader->atEnd() && !reader->hasError()) {
QXmlStreamReader::TokenType token = reader->readNext();
if(token == QXmlStreamReader::StartDocument)
continue;
if(token == QXmlStreamReader::StartElement) {
if(reader->name() == "IsSetting")
{
QString str = reader->readElementText();
if(str == "True")
{
//continue
}
else
{
writer->setAutoFormatting(true);
writer->writeStartDocument();
writer->writeStartElement("Application");
writer->writeTextElement("IP", "192.168.2.45");
}
}
}
}
return a.exec();
}
//=============================================================================
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;
}
