void GeoResolver::Cache (QList<int> ids, QHash<int, QString>& result, GeoIdType type) { auto newEnd = std::remove_if (ids.begin (), ids.end (), [&result] (int id) { return result.contains (id); }); ids.erase (newEnd, ids.end ()); Conn_->RequestGeoIds (ids, [&result] (const QHash<int, QString>& newItems) { result.unite (newItems); }, type); }
QHash<int, QString> getMoves(const Pokemon::uniqueId &num, int gen, bool root = true) { QHash<int, QString> ret; if (gen != 1 && gen != 3) { ret = getMoves(num, gen-1, false); } return ret.unite(map_container_with_value(PokemonInfo::TMMoves(num, gen), root ? QObject::tr("TM/HM") : QObject::tr("%1G TM/HM").arg(gen))) .unite(map_container_with_value(PokemonInfo::TutorMoves(num, gen), root ? QObject::tr("Tutor") : QObject::tr("%1G Tutor").arg(gen))) .unite(map_container_with_value(PokemonInfo::LevelMoves(num, gen), root ? QObject::tr("Level") : QObject::tr("%1G Level").arg(gen))) .unite(map_container_with_value(PokemonInfo::PreEvoMoves(num, gen), root ? QObject::tr("Pre Evo") :QObject:: tr("%1G Pre Evo").arg(gen))) .unite(map_container_with_value(PokemonInfo::EggMoves(num, gen), root ? QObject::tr("Breeding") : QObject::tr("%1G Breeding").arg(gen))) .unite((gen == 5 ? map_container_with_value(PokemonInfo::dreamWorldMoves(num), QObject::tr("Dream World")) : QHash<int, QString>())) .unite(map_container_with_value(PokemonInfo::SpecialMoves(num, gen), root ? QObject::tr("Special", "Learning") : QObject::tr("%1G Special").arg(gen))); }
QHash<QString, RssFeedPtr> RssFolder::getAllFeedsAsHash() const { QHash<QString, RssFeedPtr> ret; RssFileHash::ConstIterator it = m_children.begin(); RssFileHash::ConstIterator itend = m_children.end(); for ( ; it != itend; ++it) { if (RssFeedPtr feed = qSharedPointerDynamicCast<RssFeed>(it.value())) { qDebug() << Q_FUNC_INFO << feed->url(); ret[feed->url()] = feed; } else if (RssFolderPtr folder = qSharedPointerDynamicCast<RssFolder>(it.value())) { ret.unite(folder->getAllFeedsAsHash()); } } return ret; }
void GeoResolver::Get (int code, std::function<void (QString)> setter, QHash<int, QString>& hash, GeoIdType type) { if (hash.contains (code)) { setter (hash [code]); return; } Conn_->RequestGeoIds ({ code }, [&hash, setter, code] (const QHash<int, QString>& result) { hash.unite (result); setter (result [code]); }, type); }
// Loads the referenced files into the main folder of the book; // as the files get a new name, the references are updated QHash<QString, QString> ImportHTML::LoadFolderStructure(const QString & source) { QStringList mediapaths = XhtmlDoc::GetPathsToMediaFiles(source); QStringList stylepaths = XhtmlDoc::GetPathsToStyleFiles(source); QFutureSynchronizer<QHash<QString, QString>> sync; sync.addFuture(QtConcurrent::run(this, &ImportHTML::LoadMediaFiles, mediapaths)); sync.addFuture(QtConcurrent::run(this, &ImportHTML::LoadStyleFiles, stylepaths)); sync.waitForFinished(); QList<QFuture<QHash<QString, QString>>> futures = sync.futures(); int num_futures = futures.count(); QHash<QString, QString> updates; for (int i = 0; i < num_futures; ++i) { updates.unite(futures.at(i).result()); } return updates; }
QVariantList DatasetParser::parseDataFile(QFileInfo dataFileInfo) { QVariantList datasetDescriptor; QHash<int,int> instanceDescriptor; QHash<int,QString> classDescriptor; QFile dataFile(dataFileInfo.filePath()); QString datasetDescriptionPlain; if (dataFile.open(QIODevice::ReadOnly)) datasetDescriptionPlain = dataFile.readAll(); else { qDebug(QString("Can't open file: %1").arg(dataFileInfo.absoluteFilePath()).toAscii()); return QVariantList(); } QStringList instanceDescriptionPlainList = datasetDescriptionPlain.split(instanceSeperator); QStringList headerList = instanceDescriptionPlainList.takeFirst().split(headerSeperator); int instanceUniqueIDIndex = headerList.indexOf(instanceUniqueIDHeader); int classNameIndex = headerList.indexOf(classNameHeader); int classIDIndex = headerList.indexOf(classIDHeader); foreach (QString instanceDescriptionPlain, instanceDescriptionPlainList) { QStringList instanceDescriptionList = instanceDescriptionPlain.split(headerSeperator); QString className = instanceDescriptionList[classNameIndex]; int classID = instanceDescriptionList[classIDIndex].toInt(); if (!classDescriptor[classID].isEmpty()) { if (classDescriptor[classID] != className) { qDebug(QString("Class ID %1 is matched to classes with names %2 & %3").arg(classID).arg(classDescriptor[classIDIndex]).arg(className).toAscii()); } } else classDescriptor[classID] = className; QString instanceUniqueID = instanceDescriptionList[instanceUniqueIDIndex]; instanceDescriptor.unite(this->parseInstanceUniqueID(instanceUniqueID, classID)); }
bool XsdParticleChecker::subsumes(const XsdParticle::Ptr &particle, const XsdParticle::Ptr &derivedParticle, const XsdSchemaContext::Ptr &context, QString &errorMsg) { /** * The algorithm is implemented like described in http://www.ltg.ed.ac.uk/~ht/XML_Europe_2003.html#S2.3 */ const NamePool::Ptr namePool(context->namePool()); XsdStateMachine<XsdTerm::Ptr> baseStateMachine(namePool); XsdStateMachine<XsdTerm::Ptr> derivedStateMachine(namePool); // build up state machines for both particles { XsdStateMachineBuilder builder(&baseStateMachine, namePool); const XsdStateMachine<XsdTerm::Ptr>::StateId endState = builder.reset(); const XsdStateMachine<XsdTerm::Ptr>::StateId startState = builder.buildParticle(particle, endState); builder.addStartState(startState); baseStateMachine = baseStateMachine.toDFA(); } { XsdStateMachineBuilder builder(&derivedStateMachine, namePool); const XsdStateMachine<XsdTerm::Ptr>::StateId endState = builder.reset(); const XsdStateMachine<XsdTerm::Ptr>::StateId startState = builder.buildParticle(derivedParticle, endState); builder.addStartState(startState); derivedStateMachine = derivedStateMachine.toDFA(); } QHash<XsdTerm::Ptr, XsdParticle::Ptr> particlesHash = XsdStateMachineBuilder::particleLookupMap(particle); particlesHash.unite(XsdStateMachineBuilder::particleLookupMap(derivedParticle)); /* static int counter = 0; { QFile file(QString("/tmp/file_base%1.dot").arg(counter)); file.open(QIODevice::WriteOnly); baseStateMachine.outputGraph(&file, QLatin1String("Base")); file.close(); } { QFile file(QString("/tmp/file_derived%1.dot").arg(counter)); file.open(QIODevice::WriteOnly); derivedStateMachine.outputGraph(&file, QLatin1String("Base")); file.close(); } ::system(QString("dot -Tpng /tmp/file_base%1.dot -o/tmp/file_base%1.png").arg(counter).toLatin1().data()); ::system(QString("dot -Tpng /tmp/file_derived%1.dot -o/tmp/file_derived%1.png").arg(counter).toLatin1().data()); */ const XsdStateMachine<XsdTerm::Ptr>::StateId baseStartState = baseStateMachine.startState(); const QHash<XsdStateMachine<XsdTerm::Ptr>::StateId, XsdStateMachine<XsdTerm::Ptr>::StateType> baseStates = baseStateMachine.states(); const QHash<XsdStateMachine<XsdTerm::Ptr>::StateId, QHash<XsdTerm::Ptr, QVector<XsdStateMachine<XsdTerm::Ptr>::StateId> > > baseTransitions = baseStateMachine.transitions(); const XsdStateMachine<XsdTerm::Ptr>::StateId derivedStartState = derivedStateMachine.startState(); const QHash<XsdStateMachine<XsdTerm::Ptr>::StateId, XsdStateMachine<XsdTerm::Ptr>::StateType> derivedStates = derivedStateMachine.states(); const QHash<XsdStateMachine<XsdTerm::Ptr>::StateId, QHash<XsdTerm::Ptr, QVector<XsdStateMachine<XsdTerm::Ptr>::StateId> > > derivedTransitions = derivedStateMachine.transitions(); // @see http://www.ltg.ed.ac.uk/~ht/XML_Europe_2003.html#S2.3.1 // define working set QList<QPair<XsdStateMachine<XsdTerm::Ptr>::StateId, XsdStateMachine<XsdTerm::Ptr>::StateId> > workSet; QList<QPair<XsdStateMachine<XsdTerm::Ptr>::StateId, XsdStateMachine<XsdTerm::Ptr>::StateId> > processedSet; // 1) fill working set initially with start states workSet.append(qMakePair<XsdStateMachine<XsdTerm::Ptr>::StateId, XsdStateMachine<XsdTerm::Ptr>::StateId>(baseStartState, derivedStartState)); processedSet.append(qMakePair<XsdStateMachine<XsdTerm::Ptr>::StateId, XsdStateMachine<XsdTerm::Ptr>::StateId>(baseStartState, derivedStartState)); while (!workSet.isEmpty()) { // while there are state sets to process // 3) dequeue on state set const QPair<XsdStateMachine<XsdTerm::Ptr>::StateId, XsdStateMachine<XsdTerm::Ptr>::StateId> set = workSet.takeFirst(); const QHash<XsdTerm::Ptr, QVector<XsdStateMachine<XsdTerm::Ptr>::StateId> > derivedTrans = derivedTransitions.value(set.second); QHashIterator<XsdTerm::Ptr, QVector<XsdStateMachine<XsdTerm::Ptr>::StateId> > derivedIt(derivedTrans); const QHash<XsdTerm::Ptr, QVector<XsdStateMachine<XsdTerm::Ptr>::StateId> > baseTrans = baseTransitions.value(set.first); while (derivedIt.hasNext()) { derivedIt.next(); bool found = false; QHashIterator<XsdTerm::Ptr, QVector<XsdStateMachine<XsdTerm::Ptr>::StateId> > baseIt(baseTrans); while (baseIt.hasNext()) { baseIt.next(); if (derivedTermValid(baseIt.key(), derivedIt.key(), particlesHash, context, errorMsg)) { const QPair<XsdStateMachine<XsdTerm::Ptr>::StateId, XsdStateMachine<XsdTerm::Ptr>::StateId> endSet = qMakePair<XsdStateMachine<XsdTerm::Ptr>::StateId, XsdStateMachine<XsdTerm::Ptr>::StateId>(baseIt.value().first(), derivedIt.value().first()); if (!processedSet.contains(endSet) && !workSet.contains(endSet)) { workSet.append(endSet); processedSet.append(endSet); } found = true; } } if (!found) { return false; } } } // 5) QHashIterator<XsdStateMachine<XsdTerm::Ptr>::StateId, XsdStateMachine<XsdTerm::Ptr>::StateType> it(derivedStates); while (it.hasNext()) { it.next(); if (it.value() == XsdStateMachine<XsdTerm::Ptr>::EndState || it.value() == XsdStateMachine<XsdTerm::Ptr>::StartEndState) { for (int i = 0; i < processedSet.count(); ++i) { if (processedSet.at(i).second == it.key() && (baseStates.value(processedSet.at(i).first) != XsdStateMachine<XsdTerm::Ptr>::EndState && baseStates.value(processedSet.at(i).first) != XsdStateMachine<XsdTerm::Ptr>::StartEndState)) { errorMsg = QtXmlPatterns::tr("Derived particle allows content that is not allowed in the base particle."); return false; } } } } return true; }
bool OsmAnd::MapStyle_P::parse( QXmlStreamReader& xmlReader ) { auto rulesetType = MapStyleRulesetType::Invalid; struct Lexeme { enum Type { Rule, Group, }; Lexeme(Type type_, MapStyle_P* style_) : type(type_) , style(style_) {} const Type type; MapStyle_P* const style; }; struct Rule : public Lexeme { Rule(std::shared_ptr<MapStyleRule> rule_, MapStyle_P* style_) : Lexeme(Lexeme::Rule, style_) , rule(rule_) {} const std::shared_ptr<MapStyleRule> rule; }; struct Group : public Lexeme { Group(MapStyle_P* const style_) : Lexeme(Lexeme::Group, style_) {} QHash< QString, QString > attributes; QList< std::shared_ptr<MapStyleRule> > children; QList< std::shared_ptr<Lexeme> > subgroups; void addGroupFilter(const std::shared_ptr<MapStyleRule>& rule) { for(auto itChild = children.cbegin(); itChild != children.cend(); ++itChild) { auto child = *itChild; child->_d->_ifChildren.push_back(rule); } for(auto itSubgroup = subgroups.cbegin(); itSubgroup != subgroups.cend(); ++itSubgroup) { auto subgroup = *itSubgroup; assert(subgroup->type == Lexeme::Group); std::static_pointer_cast<Group>(subgroup)->addGroupFilter(rule); } } bool registerGlobalRules(const MapStyleRulesetType type) { for(auto itChild = children.cbegin(); itChild != children.cend(); ++itChild) { auto child = *itChild; if(!style->registerRule(type, child)) return false; } for(auto itSubgroup = subgroups.cbegin(); itSubgroup != subgroups.cend(); ++itSubgroup) { auto subgroup = *itSubgroup; assert(subgroup->type == Lexeme::Group); if(!std::static_pointer_cast<Group>(subgroup)->registerGlobalRules(type)) return false; } return true; } }; QStack< std::shared_ptr<Lexeme> > stack; while (!xmlReader.atEnd() && !xmlReader.hasError()) { xmlReader.readNext(); const auto tagName = xmlReader.name(); if (xmlReader.isStartElement()) { if(tagName == QLatin1String("renderingStyle")) { // We have already parsed metadata and resolved dependencies, so here we don't need to do anything } else if(tagName == QLatin1String("renderingConstant")) { const auto& attribs = xmlReader.attributes(); auto name = attribs.value(QLatin1String("name")).toString(); auto value = attribs.value(QLatin1String("value")).toString(); _parsetimeConstants.insert(name, value); } else if(tagName == QLatin1String("renderingProperty")) { MapStyleConfigurableInputValue* inputValue = nullptr; const auto& attribs = xmlReader.attributes(); auto name = obtainValue(attribs.value(QLatin1String("attr")).toString()); auto type = obtainValue(attribs.value(QLatin1String("type")).toString()); auto title = obtainValue(attribs.value(QLatin1String("name")).toString()); auto description = attribs.value(QLatin1String("description")).toString(); auto encodedPossibleValues = attribs.value(QLatin1String("possibleValues")); QStringList possibleValues; if(!encodedPossibleValues.isEmpty()) possibleValues = encodedPossibleValues.toString().split(',', QString::SkipEmptyParts); for(auto itPossibleValue = possibleValues.begin(); itPossibleValue != possibleValues.end(); ++itPossibleValue) { auto& possibleValue = *itPossibleValue; possibleValue = obtainValue(possibleValue); } if(type == QLatin1String("string")) { inputValue = new MapStyleConfigurableInputValue( MapStyleValueDataType::String, name, title, description, possibleValues); } else if(type == QLatin1String("boolean")) { inputValue = new MapStyleConfigurableInputValue( MapStyleValueDataType::Boolean, name, title, description, possibleValues); } else // treat as integer { inputValue = new MapStyleConfigurableInputValue( MapStyleValueDataType::Integer, name, title, description, possibleValues); } registerValue(inputValue); } else if(tagName == QLatin1String("renderingAttribute")) { const auto& attribs = xmlReader.attributes(); auto name = obtainValue(attribs.value(QLatin1String("name")).toString()); std::shared_ptr<MapStyleRule> attribute(new MapStyleRule(owner, QHash< QString, QString >())); _attributes.insert(name, attribute); std::shared_ptr<Lexeme> selector(new Rule(attribute, this)); stack.push(qMove(selector)); } else if(tagName == QLatin1String("filter")) { QHash< QString, QString > ruleAttributes; if(!stack.isEmpty()) { auto lexeme = stack.top(); if(lexeme->type == Lexeme::Group) ruleAttributes.unite(std::static_pointer_cast<Group>(lexeme)->attributes); } const auto& attribs = xmlReader.attributes(); for(auto itXmlAttrib = attribs.cbegin(); itXmlAttrib != attribs.cend(); ++itXmlAttrib) { const auto& xmlAttrib = *itXmlAttrib; const auto tag = xmlAttrib.name().toString(); const auto value = obtainValue(xmlAttrib.value().toString()); ruleAttributes.insert(qMove(tag), qMove(value)); } const std::shared_ptr<MapStyleRule> rule(new MapStyleRule(owner, ruleAttributes)); if(!stack.isEmpty()) { auto lexeme = stack.top(); if(lexeme->type == Lexeme::Group) { std::static_pointer_cast<Group>(lexeme)->children.push_back(rule); } else if(lexeme->type == Lexeme::Rule) { std::static_pointer_cast<Rule>(lexeme)->rule->_d->_ifElseChildren.push_back(rule); } } else { if(!registerRule(rulesetType, rule)) return false; } stack.push(qMove(std::shared_ptr<Lexeme>(new Rule(rule, this)))); } else if(tagName == QLatin1String("groupFilter")) { QHash< QString, QString > attributes; const auto& attribs = xmlReader.attributes(); for(auto itXmlAttrib = attribs.cbegin(); itXmlAttrib != attribs.cend(); ++itXmlAttrib) { const auto& xmlAttrib = *itXmlAttrib; const auto tag = xmlAttrib.name().toString(); const auto value = obtainValue(xmlAttrib.value().toString()); attributes.insert(qMove(tag), qMove(value)); } std::shared_ptr<MapStyleRule> rule(new MapStyleRule(owner, attributes)); if(stack.isEmpty()) { OsmAnd::LogPrintf(OsmAnd::LogSeverityLevel::Error, "Group filter without parent"); return false; } auto lexeme = stack.top(); if(lexeme->type == Lexeme::Group) { std::static_pointer_cast<Group>(lexeme)->addGroupFilter(rule); } else if(lexeme->type == Lexeme::Rule) { std::static_pointer_cast<Rule>(lexeme)->rule->_d->_ifChildren.push_back(rule); } stack.push(qMove(std::shared_ptr<Lexeme>(new Rule(rule, this)))); } else if(tagName == QLatin1String("group")) { const auto group = new Group(this); if(!stack.isEmpty()) { auto lexeme = stack.top(); if(lexeme->type == Lexeme::Group) group->attributes.unite(std::static_pointer_cast<Group>(lexeme)->attributes); } const auto& attribs = xmlReader.attributes(); for(auto itXmlAttrib = attribs.cbegin(); itXmlAttrib != attribs.cend(); ++itXmlAttrib) { const auto& xmlAttrib = *itXmlAttrib; const auto tag = xmlAttrib.name().toString(); const auto value = obtainValue(xmlAttrib.value().toString()); group->attributes.insert(qMove(tag), qMove(value)); } stack.push(qMove(std::shared_ptr<Lexeme>(group))); } else if(tagName == QLatin1String("order")) { rulesetType = MapStyleRulesetType::Order; } else if(tagName == QLatin1String("text")) { rulesetType = MapStyleRulesetType::Text; } else if(tagName == QLatin1String("point")) { rulesetType = MapStyleRulesetType::Point; } else if(tagName == QLatin1String("line")) { rulesetType = MapStyleRulesetType::Polyline; } else if(tagName == QLatin1String("polygon")) { rulesetType = MapStyleRulesetType::Polygon; } } else if(xmlReader.isEndElement()) { if(tagName == QLatin1String("filter")) { stack.pop(); } else if(tagName == QLatin1String("group")) { const auto lexeme = stack.pop(); if (stack.isEmpty()) { assert(lexeme->type == Lexeme::Group); if(!std::static_pointer_cast<Group>(lexeme)->registerGlobalRules(rulesetType)) return false; } else { const auto group = stack.top(); if(group->type == Lexeme::Group) std::static_pointer_cast<Group>(group)->subgroups.push_back(qMove(lexeme)); } } else if(tagName == QLatin1String("groupFilter")) { stack.pop(); } else if(tagName == QLatin1String("renderingAttribute")) { stack.pop(); } } } if(xmlReader.hasError()) { std::cerr << qPrintable(xmlReader.errorString()) << "(" << xmlReader.lineNumber() << ", " << xmlReader.columnNumber() << ")" << std::endl; return false; } return true; }
void KernelModel::update() { QHash<QString, QString> installedKernelPackages = getInstalledPackages(); QHash<QString, QString> availableKernelPackages = getAvailablePackages(); QHash<QString, QString> allKernelPackages; allKernelPackages.unite( installedKernelPackages ); QHashIterator<QString, QString> i( availableKernelPackages ); while ( i.hasNext() ) { i.next(); allKernelPackages.insert( i.key(), i.value() ); } QString runningKernel = getRunningKernel(); QStringList ltsKernels = getLtsKernels(); QStringList recommendedKernels = getRecommendedKernels(); QSet<QString> modulesToInstall; for ( const QString& module : QStringList( installedKernelPackages.keys() ).filter( QRegularExpression( "^linux[0-9][0-9]?([0-9])-" ) ) ) { QString aux = QString( module ).remove( QRegularExpression( "^linux[0-9][0-9]?([0-9])-" ) ); modulesToInstall.insert( aux ); } beginResetModel(); m_kernels.clear(); for ( const QString& kernel : QStringList( allKernelPackages.keys() ).filter( QRegularExpression( "^linux[0-9][0-9]?([0-9])$" ) ) ) { Kernel newKernel; newKernel.setPackage( kernel ); newKernel.setAvailable( availableKernelPackages.contains( kernel ) ); newKernel.setInstalled( installedKernelPackages.contains( kernel ) ); newKernel.setVersion( allKernelPackages.value( kernel ) ); newKernel.setAvailableModules( QStringList( availableKernelPackages.keys() ) .filter( QRegularExpression( QString( "^%1-" ).arg( kernel ) ) ) ); if ( newKernel.isInstalled() ) { newKernel.setInstalledModules( QStringList( installedKernelPackages.keys() ) .filter( QRegularExpression( QString( "^%1-" ).arg( kernel ) ) ) ); } else { QStringList installableModules; for ( const QString& module : modulesToInstall ) { QString modulePackage = QString( "%1-%2" ).arg( kernel ).arg( module ); if ( availableKernelPackages.contains( modulePackage ) ) installableModules << modulePackage; } newKernel.setInstalledModules( installableModules ); } newKernel.setLts( ltsKernels.contains( kernel ) ); newKernel.setRecommended( recommendedKernels.contains( kernel ) ); newKernel.setRunning( QString::compare( runningKernel, kernel ) == 0 ); m_kernels.append( newKernel ); } endResetModel(); }