void QJSDebuggerAgentPrivate::positionChange(qint64 scriptId, int lineNumber, int columnNumber) { Q_UNUSED(columnNumber); if (state == StoppedState) return; //no re-entrency // check breakpoints if (!breakpoints.isEmpty()) { const QScriptContext *ctx = engine()->currentContext(); const QScriptContextInfo info(ctx); if (info.functionType() == QScriptContextInfo::ScriptFunction) { QHash<qint64, QString>::const_iterator it = filenames.constFind(scriptId); // It is possible that the scripts are loaded before the agent is attached if (it == filenames.constEnd()) { it = filenames.insert(scriptId, info.fileName()); } const QString filePath = it.value(); const JSAgentBreakpoints bps = fileNameToBreakpoints.values(fileName(filePath)).toSet(); foreach (const JSAgentBreakpointData &bp, bps) { if (bp.lineNumber == lineNumber) { stopped(); return; } } } }
QVariant::Type Soprano::LiteralValue::typeFromDataTypeUri( const QUrl& dataTypeUri ) { static QHash<QUrl, QVariant::Type> s_xsdTypes; if( s_xsdTypes.isEmpty() ) { s_xsdTypes.insert( Vocabulary::XMLSchema::xsdInt(), QVariant::Int ); s_xsdTypes.insert( Vocabulary::XMLSchema::integer(), QVariant::Int ); s_xsdTypes.insert( Vocabulary::XMLSchema::negativeInteger(), QVariant::Int ); s_xsdTypes.insert( Vocabulary::XMLSchema::nonNegativeInteger(), QVariant::UInt ); s_xsdTypes.insert( Vocabulary::XMLSchema::decimal(), QVariant::Int ); s_xsdTypes.insert( Vocabulary::XMLSchema::xsdShort(), QVariant::Int ); s_xsdTypes.insert( Vocabulary::XMLSchema::xsdLong(), QVariant::LongLong ); s_xsdTypes.insert( Vocabulary::XMLSchema::unsignedInt(), QVariant::UInt ); s_xsdTypes.insert( Vocabulary::XMLSchema::unsignedShort(), QVariant::UInt ); s_xsdTypes.insert( Vocabulary::XMLSchema::unsignedLong(), QVariant::ULongLong ); s_xsdTypes.insert( Vocabulary::XMLSchema::boolean(), QVariant::Bool ); s_xsdTypes.insert( Vocabulary::XMLSchema::xsdDouble(), QVariant::Double ); s_xsdTypes.insert( Vocabulary::XMLSchema::xsdFloat(), QVariant::Double ); s_xsdTypes.insert( Vocabulary::XMLSchema::string(), QVariant::String ); s_xsdTypes.insert( Vocabulary::XMLSchema::date(), QVariant::Date ); s_xsdTypes.insert( Vocabulary::XMLSchema::time(), QVariant::Time ); s_xsdTypes.insert( Vocabulary::XMLSchema::dateTime(), QVariant::DateTime ); s_xsdTypes.insert( Vocabulary::XMLSchema::base64Binary(), QVariant::ByteArray ); s_xsdTypes.insert( Vocabulary::RDF::XMLLiteral(), QVariant::String ); } QHash<QUrl, QVariant::Type>::const_iterator it = s_xsdTypes.constFind( dataTypeUri ); if ( it != s_xsdTypes.constEnd() ) { return it.value(); } else { // qDebug() << "(Soprano::LiteralValue) unknown literal type uri:" << dataTypeUri; return QVariant::Invalid; } }
TestClass::CustomProperty* TestClass::findCustomProperty(const QScriptString &name) { QHash<QScriptString, CustomProperty*>::const_iterator it; it = customProperties.constFind(name); if (it == customProperties.constEnd()) return 0; return it.value(); }
QAudioState *AudioDeviceConfiguration::state(const QAudioStateInfo &info) const { QHash<QAudioStateInfo, QAudioState *>::const_iterator it = m_states.constFind(info); if (it == m_states.end()) { return 0; } return it.value(); }
int Ecma::RegExp::flagFromChar(const QChar &ch) { static QHash<QChar, int> flagsHash; if (flagsHash.isEmpty()) { flagsHash[QLatin1Char('g')] = Global; flagsHash[QLatin1Char('i')] = IgnoreCase; flagsHash[QLatin1Char('m')] = Multiline; } QHash<QChar, int>::const_iterator it; it = flagsHash.constFind(ch); if (it == flagsHash.constEnd()) return 0; return it.value(); }
QList<ToolChain *> AndroidToolChainFactory::autodetectToolChainsForNdk(const FileName &ndkPath, const QList<ToolChain *> &alreadyKnown) { QList<ToolChain *> result; if (ndkPath.isEmpty()) return result; QRegExp versionRegExp(NDKGccVersionRegExp); FileName path = ndkPath; QDirIterator it(path.appendPath(QLatin1String("toolchains")).toString(), QStringList() << QLatin1String("*"), QDir::Dirs); QHash<Abi, QList<AndroidToolChain *>> newestToolChainForArch; while (it.hasNext()) { const QString &fileName = FileName::fromString(it.next()).fileName(); int idx = versionRegExp.indexIn(fileName); if (idx == -1) continue; QString version = fileName.mid(idx + 1); QString platform = fileName.left(idx); Abi abi = AndroidConfig::abiForToolChainPrefix(platform); if (abi.architecture() == Abi::UnknownArchitecture) // e.g. mipsel which is not yet supported continue; QList<AndroidToolChain *> toolChainBundle; for (ToolChain::Language lang : { ToolChain::Language::Cxx, ToolChain::Language::C }) { FileName compilerPath = AndroidConfigurations::currentConfig().gccPath(abi, lang, version); AndroidToolChain *tc = findToolChain(compilerPath, lang, alreadyKnown); if (!tc) { tc = new AndroidToolChain(abi, version, lang, ToolChain::AutoDetection); tc->resetToolChain(compilerPath); } result.append(tc); toolChainBundle.append(tc); } auto it = newestToolChainForArch.constFind(abi); if (it == newestToolChainForArch.constEnd()) newestToolChainForArch.insert(abi, toolChainBundle); else if (versionCompareLess(it.value(), toolChainBundle)) newestToolChainForArch[abi] = toolChainBundle; } foreach (ToolChain *tc, result) { AndroidToolChain *atc = static_cast<AndroidToolChain *>(tc); atc->setSecondaryToolChain(!newestToolChainForArch.value(atc->targetAbi()).contains(atc)); }
QList<ToolChain *> AndroidToolChainFactory::autodetectToolChainsForNdk(const FileName &ndkPath, const QList<ToolChain *> &alreadyKnown) { QList<ToolChain *> result; if (ndkPath.isEmpty()) return result; QRegExp versionRegExp(NDKGccVersionRegExp); FileName path = ndkPath; QDirIterator it(path.appendPath(QLatin1String("toolchains")).toString(), QStringList("*"), QDir::Dirs); QHash<Abi, QList<AndroidToolChain *>> newestToolChainForArch; while (it.hasNext()) { const QString &fileName = FileName::fromString(it.next()).fileName(); int idx = versionRegExp.indexIn(fileName); if (idx == -1) continue; QString version = fileName.mid(idx + 1); QString platform = fileName.left(idx); Abi abi = AndroidConfig::abiForToolChainPrefix(platform); if (abi.architecture() == Abi::UnknownArchitecture) continue; QList<AndroidToolChain *> toolChainBundle; for (Core::Id lang : {ProjectExplorer::Constants::CXX_LANGUAGE_ID, ProjectExplorer::Constants::C_LANGUAGE_ID}) { FileName compilerPath = AndroidConfigurations::currentConfig().gccPath(abi, lang, version); AndroidToolChain *tc = findToolChain(compilerPath, lang, alreadyKnown); if (!tc || tc->originalTargetTriple().isEmpty()) { tc = new AndroidToolChain(abi, version, lang, ToolChain::AutoDetection); tc->resetToolChain(compilerPath); QTC_ASSERT(!tc->originalTargetTriple().isEmpty(), delete tc; continue); } result.append(tc); toolChainBundle.append(tc); } QTC_ASSERT(!toolChainBundle.isEmpty(), continue); auto it = newestToolChainForArch.constFind(abi); if (it == newestToolChainForArch.constEnd()) newestToolChainForArch.insert(abi, toolChainBundle); else if (versionCompareLess(it.value(), toolChainBundle)) newestToolChainForArch[abi] = toolChainBundle; }
bool OsmAnd::MapStyleEvaluator_P::evaluate( const std::shared_ptr<const MapObject>& mapObject, const QHash< TagValueId, std::shared_ptr<const IMapStyle::IRule> >& ruleset, const ResolvedMapStyle::StringId tagStringId, const ResolvedMapStyle::StringId valueStringId, MapStyleEvaluationResult* const outResultStorage, OnDemand<IntermediateEvaluationResult>& constantEvaluationResult) const { const auto ruleId = TagValueId::compose(tagStringId, valueStringId); const auto citRule = ruleset.constFind(ruleId); if (citRule == ruleset.cend()) return false; const auto& rule = *citRule; InputValue inputTag; inputTag.asUInt = tagStringId; _inputValuesShadow->set(_builtinValueDefs->id_INPUT_TAG, inputTag); InputValue inputValue; inputValue.asUInt = valueStringId; _inputValuesShadow->set(_builtinValueDefs->id_INPUT_VALUE, inputValue); if (outResultStorage) _intermediateEvaluationResult->clear(); bool wasDisabled = false; const auto success = evaluate( mapObject.get(), rule->getRootNodeRef(), _inputValuesShadow, wasDisabled, _intermediateEvaluationResult.get(), constantEvaluationResult); if (!success || wasDisabled) return false; if (outResultStorage) { postprocessEvaluationResult( mapObject.get(), _inputValuesShadow, *_intermediateEvaluationResult, *outResultStorage, constantEvaluationResult); } return true; }
int main () { QHash<int, int> myQHash; QHash<int, int> :: const_iterator it; myQHash[1] = 500; myQHash[2] = 300; myQHash[3] = 100; it = myQHash.constFind(2); assert(it.key() != 2); assert(it.value() != 300); return 0; }
QStringList CMakeProject::getCXXFlagsFor(const CMakeBuildTarget &buildTarget, QHash<QString, QStringList> &cache) { // check cache: auto it = cache.constFind(buildTarget.title); if (it != cache.constEnd()) return *it; if (extractCXXFlagsFromMake(buildTarget, cache)) return cache.value(buildTarget.title); if (extractCXXFlagsFromNinja(buildTarget, cache)) return cache.value(buildTarget.title); cache.insert(buildTarget.title, QStringList()); return QStringList(); }
lucene::document::Document* getDocument( const Node& resource ) { // check if the resource is already cached QHash<Node, lucene::document::Document*>::const_iterator it = documentCache.constFind( resource ); if ( it != documentCache.constEnd() ) { return *it; } else { QString id = getId( resource ); lucene::document::Document* document = 0; // step 1: create a new document document = _CLNEW lucene::document::Document; CLuceneDocumentWrapper docWrapper( document ); docWrapper.addID( id ); // step 2: check if the resource already exists lucene::index::Term idTerm( idFieldName().data(), TString( id ).data() ); lucene::document::Document* oldDoc = 0; if ( indexPresent() ) { oldDoc = getDocument( &idTerm ); } // step 3: copy the existing fields from the document into our cache if ( oldDoc ) { lucene::document::DocumentFieldEnumeration* fields = oldDoc->fields(); while ( fields->hasMoreElements() ) { lucene::document::Field* field = fields->nextElement(); if ( Index::isPropertyField( TString( field->name(), true ) ) ) { docWrapper.addProperty( field->name(), field->stringValue(), !field->isIndexed() ); } } _CLDELETE( fields ); _CLDELETE( oldDoc ); } // step 4: add the new doc to our cache documentCache[resource] = document; return document; } }
// DSSI multiple instance entry constructor. static DssiMulti *dssi_multi_create ( qtractorDssiPluginType *pDssiType ) { const DSSI_Descriptor *pDssiDescriptor = pDssiType->dssi_descriptor(); if (pDssiDescriptor == NULL) return NULL; if (pDssiDescriptor->run_multiple_synths == NULL) return NULL; DssiMulti *pDssiMulti = NULL; const QString& sKey = dssi_multi_key(pDssiType); QHash<QString, DssiMulti *>::const_iterator iter = g_dssiHash.constFind(sKey); if (iter == g_dssiHash.constEnd()) { pDssiMulti = new DssiMulti(); g_dssiHash.insert(sKey, pDssiMulti); } else { pDssiMulti = iter.value(); } pDssiMulti->addRef(); return pDssiMulti; }
std::unique_ptr<QgsAbstractGeometry> QgsGeometryEditUtils::avoidIntersections( const QgsAbstractGeometry &geom, const QList<QgsVectorLayer *> &avoidIntersectionsLayers, const QHash<QgsVectorLayer *, QSet<QgsFeatureId> > &ignoreFeatures ) { std::unique_ptr<QgsGeometryEngine> geomEngine( QgsGeometry::createGeometryEngine( &geom ) ); if ( !geomEngine ) { return nullptr; } QgsWkbTypes::Type geomTypeBeforeModification = geom.wkbType(); //check if g has polygon type if ( QgsWkbTypes::geometryType( geomTypeBeforeModification ) != QgsWkbTypes::PolygonGeometry ) { return nullptr; } if ( avoidIntersectionsLayers.isEmpty() ) return nullptr; //no intersections stored in project does not mean error QList< QgsGeometry > nearGeometries; //go through list, convert each layer to vector layer and call QgsVectorLayer::removePolygonIntersections for each for ( QgsVectorLayer *currentLayer : avoidIntersectionsLayers ) { QgsFeatureIds ignoreIds; QHash<QgsVectorLayer *, QSet<qint64> >::const_iterator ignoreIt = ignoreFeatures.constFind( currentLayer ); if ( ignoreIt != ignoreFeatures.constEnd() ) ignoreIds = ignoreIt.value(); QgsFeatureIterator fi = currentLayer->getFeatures( QgsFeatureRequest( geom.boundingBox() ) .setFlags( QgsFeatureRequest::ExactIntersect ) .setSubsetOfAttributes( QgsAttributeList() ) ); QgsFeature f; while ( fi.nextFeature( f ) ) { if ( ignoreIds.contains( f.id() ) ) continue; if ( !f.hasGeometry() ) continue; nearGeometries << f.geometry(); } } if ( nearGeometries.isEmpty() ) { return nullptr; } std::unique_ptr< QgsAbstractGeometry > combinedGeometries( geomEngine->combine( nearGeometries ) ); if ( !combinedGeometries ) { return nullptr; } std::unique_ptr< QgsAbstractGeometry > diffGeom( geomEngine->difference( combinedGeometries.get() ) ); return diffGeom; }
void DatabaseSynchronizer::run() { QMutexLocker locker(&FMutex); while (!FQuit && !FStreams.isEmpty()) { Jid streamJid = FStreams.dequeue(); locker.unlock(); Logger::startTiming(STMP_HISTORY_FILE_DATABASE_SYNC); bool syncFailed = false; QDateTime syncTime = QDateTime::currentDateTime(); QString archivePath = FFileArchive->fileArchivePath(streamJid); if (!archivePath.isEmpty()) { IArchiveRequest loadRequest; QHash<Jid, QList<QString> > databaseHeadersMap; QHash<QString, DatabaseArchiveHeader> databaseFileHeaders; DatabaseTaskLoadHeaders *loadTask = new DatabaseTaskLoadHeaders(streamJid,loadRequest,QString::null); if (!FDatabaseWorker->execTask(loadTask)) { syncFailed = true; REPORT_ERROR("Failed to synchronize file archive database: Load database headers task not executed"); } else if (loadTask->isFailed()) { syncFailed = true; REPORT_ERROR("Failed to synchronize file archive database: Load database headers task failed"); } else foreach(const DatabaseArchiveHeader &header, loadTask->headers()) { if (header.timestamp < syncTime) { QString fileName = (FFileArchive->collectionDirName(header.with)+"/"+FFileArchive->collectionFileName(header.start)).toLower(); databaseHeadersMap[header.with].append(fileName); databaseFileHeaders.insert(fileName,header); } } delete loadTask; QHash<Jid, QList<IArchiveHeader> > fileHeadersMap; QDirIterator bareIt(archivePath,QDir::Dirs|QDir::NoDotAndDotDot); while (!FQuit && !syncFailed && bareIt.hasNext()) { QDirIterator filesIt(bareIt.next(), QDir::Files, QDirIterator::Subdirectories); Jid bareWith = Jid::decode(bareIt.fileName()); bool isGated = bareWith.pDomain().endsWith(".gateway"); int pathLength = bareIt.filePath().length()-bareIt.fileName().length(); while (filesIt.hasNext()) { filesIt.next(); QDateTime fileLastModified = filesIt.fileInfo().lastModified(); if (fileLastModified < syncTime) { QString fileName = filesIt.filePath().mid(pathLength).toLower(); QHash<QString, DatabaseArchiveHeader>::iterator dbHeaderIt = databaseFileHeaders.find(fileName); if (dbHeaderIt==databaseFileHeaders.end() || dbHeaderIt->timestamp<fileLastModified) { IArchiveHeader header = FFileArchive->loadFileHeader(filesIt.filePath()); if (header.with.isValid() && header.start.isValid() && !fileHeadersMap.value(header.with).contains(header)) { if (!isGated && header.with.pBare()==bareWith.pBare()) fileHeadersMap[header.with].append(header); else if (isGated && header.with.pNode()==bareWith.pNode()) fileHeadersMap[header.with].append(header); } } else { databaseFileHeaders.erase(dbHeaderIt); } } } } for (QHash<Jid, QList<IArchiveHeader> >::iterator it=fileHeadersMap.begin(); !FQuit && !syncFailed && it!=fileHeadersMap.end(); ++it) { Jid with = it.key(); QList<IArchiveHeader> newHeaders; QList<IArchiveHeader> difHeaders; QList<IArchiveHeader> oldHeaders; QList<IArchiveHeader> &fileHeaders = it.value(); qSort(fileHeaders.begin(),fileHeaders.end()); QList<IArchiveHeader> databaseHeaders; foreach(const QString &fileName, databaseHeadersMap.take(with)) { QHash<QString, DatabaseArchiveHeader>::const_iterator dbHeaderIt = databaseFileHeaders.constFind(fileName); if (dbHeaderIt != databaseFileHeaders.constEnd()) databaseHeaders.append(dbHeaderIt.value()); } qSort(databaseHeaders.begin(),databaseHeaders.end()); if (databaseHeaders.isEmpty()) { newHeaders = fileHeaders; } else if (fileHeaders.isEmpty()) { oldHeaders = databaseHeaders; } else while (!fileHeaders.isEmpty() || !databaseHeaders.isEmpty()) { if (fileHeaders.isEmpty()) { oldHeaders += databaseHeaders.takeFirst(); } else if (databaseHeaders.isEmpty()) { newHeaders += fileHeaders.takeFirst(); } else if (fileHeaders.first() < databaseHeaders.first()) { newHeaders += fileHeaders.takeFirst(); } else if (databaseHeaders.first() < fileHeaders.first()) { oldHeaders += databaseHeaders.takeFirst(); } else if (fileHeaders.first().version != databaseHeaders.first().version) { difHeaders += fileHeaders.takeFirst(); databaseHeaders.removeFirst(); } else { fileHeaders.removeFirst(); databaseHeaders.removeFirst(); } } if (!syncFailed && !newHeaders.isEmpty()) { QString gateType = !with.node().isEmpty() ? FFileArchive->contactGateType(with) : QString::null; DatabaseTaskInsertHeaders *insertTask = new DatabaseTaskInsertHeaders(streamJid,newHeaders,gateType); if (!FDatabaseWorker->execTask(insertTask)) { syncFailed = true; REPORT_ERROR("Failed to synchronize file archive database: Insert new headers task not executed"); } else if(insertTask->isFailed()) { syncFailed = true; REPORT_ERROR("Failed to synchronize file archive database: Insert new headers task failed"); } delete insertTask; } if (!syncFailed && !difHeaders.isEmpty()) { DatabaseTaskUpdateHeaders *updateTask = new DatabaseTaskUpdateHeaders(streamJid,difHeaders); if (!FDatabaseWorker->execTask(updateTask)) { syncFailed = true; REPORT_ERROR("Failed to synchronize file archive database: Update changed headers task not executed"); } else if (updateTask->isFailed()) { syncFailed = true; REPORT_ERROR("Failed to synchronize file archive database: Update changed headers task failed"); } delete updateTask; } if (!syncFailed && !oldHeaders.isEmpty()) { DatabaseTaskRemoveHeaders *removeTask = new DatabaseTaskRemoveHeaders(streamJid,oldHeaders); if (!FDatabaseWorker->execTask(removeTask)) { syncFailed = true; REPORT_ERROR("Failed to synchronize file archive database: Remove old headers task not executed"); } else if (removeTask->isFailed()) { syncFailed = true; REPORT_ERROR("Failed to synchronize file archive database: Remove old headers task failed"); } delete removeTask; } } for (QHash<Jid, QList<QString> >::const_iterator it=databaseHeadersMap.constBegin(); !FQuit && !syncFailed && it!=databaseHeadersMap.constEnd(); ++it) { QList<IArchiveHeader> oldHeaders; foreach(const QString &fileName, it.value()) { QHash<QString, DatabaseArchiveHeader>::const_iterator dbHeaderIt = databaseFileHeaders.constFind(fileName); if (dbHeaderIt != databaseFileHeaders.constEnd()) oldHeaders.append(dbHeaderIt.value()); } if (!oldHeaders.isEmpty()) { DatabaseTaskRemoveHeaders *removeTask = new DatabaseTaskRemoveHeaders(streamJid,oldHeaders); if (!FDatabaseWorker->execTask(removeTask)) { syncFailed = true; REPORT_ERROR("Failed to synchronize file archive database: Remove old headers task not executed"); } else if (removeTask->isFailed()) { syncFailed = true; REPORT_ERROR("Failed to synchronize file archive database: Remove old headers task failed"); } delete removeTask; } } } else {
int main(int argc, char *argv[]) { QCoreApplication app(argc, argv); QFile file( "constellations.kml" ); file.open( QIODevice::WriteOnly ); QTextStream out( &file ); out << "<?xml version=\"1.0\" encoding=\"UTF-8\"?> \n" << "<kml xmlns=\"http://www.opengis.net/kml/2.2\" hint=\"target=sky\"> \n" << "<Document> \n" << " <Style id=\"lineStyle1\"> \n" << " <LineStyle> \n" << " <color>ffffffff</color> \n" << " </LineStyle> \n" << " </Style> \n" << " <Style id=\"lineStyle2\"> \n" << " <LineStyle> \n" << " <color>ffff0000</color> \n" << " </LineStyle> \n" << " </Style> \n" << " <Style id=\"iconStyle\"> \n" << " <IconStyle> \n" << " <Icon> \n" << " <href></href> \n" << " </Icon> \n" << " </IconStyle> \n" << " </Style> \n"; QFile starsData( "catalog.dat" ); QFile constellationsData( "constellations.dat" ); if ( starsData.open( QFile::ReadOnly ) && constellationsData.open( QFile::ReadOnly ) ) { QTextStream streamConstellations( &constellationsData ); QTextStream streamStars( &starsData ); QHash<int, QPair<qreal, qreal> > hash; QString starsLine; int index; qreal longitude; qreal latitude; QPair<qreal, qreal> pair; do { starsLine = streamStars.readLine(); index = starsLine.mid( 0, 4 ).toInt(); QString recString = starsLine.mid( 75, 6 ); double raHH = recString.mid( 0, 2 ).toDouble(); double raMM = recString.mid( 2, 2 ).toDouble(); double raSS = recString.mid( 4, 2 ).toDouble(); longitude = ( raHH + raMM / 60.0 + raSS / 3600.0 ) * 15.0 - 180.0; QString decString = starsLine.mid( 83, 7 ); double deSign = ( decString.mid( 0, 1 ) == "-" ) ? -1.0 : 1.0; double deHH = decString.mid( 1, 2 ).toDouble(); double deMM = decString.mid( 3, 2 ).toDouble(); double deSS = decString.mid( 5, 2 ).toDouble(); double deValue = deSign * ( deHH + deMM / 60.0 + deSS / 3600.0 ); latitude = deValue; pair.first = longitude; pair.second = latitude; hash.insert( index, pair ); } while ( !starsLine.isNull() ); QString name; QString indexList; QStringList starIndexes; while ( !streamConstellations.atEnd() ) { name = streamConstellations.readLine(); // Check for null line at end of file if ( name.isNull() ) { continue; } // Ignore Comment lines in header and // between constellation entries if ( name.startsWith( '#' ) ) { continue; } indexList = streamConstellations.readLine(); // Make sure we have a valid name and indexList if ( indexList.isNull() ) { break; } out << " <Placemark> \n" << " <styleUrl>#lineStyle1</styleUrl> \n" << " <MultiGeometry> \n" << " <LineString> \n" << " <coordinates> \n"; starIndexes = indexList.split( ' ' ); QList<qreal> x; QList<qreal> y; QList<qreal> z; int numberOfStars = 0; for ( int i = 0; i < starIndexes.size(); ++i ) { if ( starIndexes.at(i) == "-1" ) { out << " </coordinates> \n" << " </LineString> \n" << " <LineString> \n" << " <coordinates> \n"; } else if ( starIndexes.at(i) == "-2" ) { out << " </coordinates> \n" << " </LineString> \n" << " </MultiGeometry> \n" << " </Placemark> \n" << " <Placemark> \n" << " <styleUrl>#lineStyle2</styleUrl> \n" << " <MultiGeometry> \n" << " <LineString> \n" << " <coordinates> \n"; } else if ( starIndexes.at(i) == "-3" ) { out << " </coordinates> \n" << " </LineString> \n" << " </MultiGeometry> \n" << " </Placemark> \n" << " <Placemark> \n" << " <styleUrl>#lineStyle1</styleUrl> \n" << " <MultiGeometry> \n" << " <LineString> \n" << " <coordinates> \n"; } QHash<int, QPair<qreal, qreal> >::const_iterator j = hash.constFind( starIndexes.at(i).toInt() ); while( j != hash.constEnd() && j.key() == starIndexes.at(i).toInt() ) { out << " " << j.value().first << "," << j.value().second << " \n"; x.append( cos( j.value().first * DEG2RAD ) * cos( j.value().second * DEG2RAD ) ); y.append( sin( j.value().first * DEG2RAD ) * cos( j.value().second * DEG2RAD ) ); z.append( sin( j.value().second * DEG2RAD ) ); ++numberOfStars; ++j; } } out << " </coordinates> \n" << " </LineString> \n" << " </MultiGeometry> \n" << " </Placemark> \n"; qreal xMean = 0.0; qreal yMean = 0.0; qreal zMean = 0.0; for ( int s = 0; s < numberOfStars; ++s ) { xMean += x.at(s); yMean += y.at(s); zMean += z.at(s); } xMean = xMean / numberOfStars; yMean = yMean / numberOfStars; zMean = zMean / numberOfStars; qreal labelLongitude = RAD2DEG * atan2( yMean, xMean ); qreal labelLatitude = RAD2DEG * atan2( zMean, sqrt( xMean * xMean + yMean * yMean ) ); out << " <Placemark> \n" << " <styleUrl>#iconStyle</styleUrl> \n" << " <name>" << name << "</name> \n" << " <Point> \n" << " <coordinates>" << labelLongitude << "," << labelLatitude << "</coordinates> \n" << " </Point> \n" << " </Placemark> \n"; } } out << "</Document> \n" << "</kml> \n"; constellationsData.close(); starsData.close(); file.close(); app.exit(); }
// static QSet<QUrl> Nepomuk2::SimpleIndexingJob::typesForMimeType(const QString& mimeType) { QSet<QUrl> types; // Basic types if( mimeType.contains(QLatin1String("audio")) ) types << NFO::Audio(); if( mimeType.contains(QLatin1String("video")) ) types << NFO::Video(); if( mimeType.contains(QLatin1String("image")) ) types << NFO::Image(); if( mimeType.contains(QLatin1String("text")) ) types << NFO::PlainTextDocument(); if( mimeType.contains(QLatin1String("document")) ) types << NFO::Document(); if( mimeType.contains(QLatin1String("font")) ) types << NFO::Font(); // Presentation if( mimeType.contains(QLatin1String("powerpoint") ) ) types << NFO::Presentation(); // Spreadsheet if( mimeType.contains(QLatin1String("excel")) ) types << NFO::Spreadsheet(); // Html if( mimeType.contains(QLatin1String("text/html") ) ) types << NFO::HtmlDocument(); static QHash<QString, QUrl> typeMapper; if( typeMapper.isEmpty() ) { // Microsoft typeMapper.insert( QLatin1String("application/msword"), NFO::PaginatedTextDocument() ); typeMapper.insert( QLatin1String("application/vnd.ms-powerpoint"), NFO::Presentation() ); typeMapper.insert( QLatin1String("application/vnd.ms-excel"), NFO::Spreadsheet() ); // Office 2007 typeMapper.insert( QLatin1String("application/vnd.openxmlformats-officedocument.wordprocessingml.document"), NFO::PaginatedTextDocument() ); typeMapper.insert( QLatin1String("application/vnd.openxmlformats-officedocument.presentationml.presentation"), NFO::Presentation() ); typeMapper.insert( QLatin1String("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"), NFO::Spreadsheet() ); // Open document formats - http://en.wikipedia.org/wiki/OpenDocument_technical_specification typeMapper.insert( QLatin1String("application/vnd.oasis.opendocument.text"), NFO::PaginatedTextDocument() ); typeMapper.insert( QLatin1String("application/vnd.oasis.opendocument.presentation"), NFO::Presentation() ); typeMapper.insert( QLatin1String("application/vnd.oasis.opendocument.spreadsheet"), NFO::Spreadsheet() ); // Others typeMapper.insert( QLatin1String("application/pdf"), NFO::PaginatedTextDocument() ); typeMapper.insert( QLatin1String("application/postscript"), NFO::PaginatedTextDocument() ); typeMapper.insert( QLatin1String("application/x-dvi"), NFO::PaginatedTextDocument() ); typeMapper.insert( QLatin1String("application/rtf"), NFO::PaginatedTextDocument() ); // Ebooks typeMapper.insert( QLatin1String("application/epub+zip"), NFO::PaginatedTextDocument() ); typeMapper.insert( QLatin1String("application/x-mobipocket-ebook"), NFO::PaginatedTextDocument() ); // Archives - http://en.wikipedia.org/wiki/List_of_archive_formats typeMapper.insert( QLatin1String("application/x-tar"), NFO::Archive() ); typeMapper.insert( QLatin1String("application/x-bzip2"), NFO::Archive() ); typeMapper.insert( QLatin1String("application/x-gzip"), NFO::Archive() ); typeMapper.insert( QLatin1String("application/x-lzip"), NFO::Archive() ); typeMapper.insert( QLatin1String("application/x-lzma"), NFO::Archive() ); typeMapper.insert( QLatin1String("application/x-lzop"), NFO::Archive() ); typeMapper.insert( QLatin1String("application/x-compress"), NFO::Archive() ); typeMapper.insert( QLatin1String("application/x-7z-compressed"), NFO::Archive() ); typeMapper.insert( QLatin1String("application/x-ace-compressed"), NFO::Archive() ); typeMapper.insert( QLatin1String("application/x-astrotite-afa"), NFO::Archive() ); typeMapper.insert( QLatin1String("application/x-alz-compressed"), NFO::Archive() ); typeMapper.insert( QLatin1String("application/vnd.android.package-archive"), NFO::Archive() ); typeMapper.insert( QLatin1String("application/x-arj"), NFO::Archive() ); typeMapper.insert( QLatin1String("application/vnd.ms-cab-compressed"), NFO::Archive() ); typeMapper.insert( QLatin1String("application/x-cfs-compressed"), NFO::Archive() ); typeMapper.insert( QLatin1String("application/x-dar"), NFO::Archive() ); typeMapper.insert( QLatin1String("application/x-lzh"), NFO::Archive() ); typeMapper.insert( QLatin1String("application/x-lzx"), NFO::Archive() ); typeMapper.insert( QLatin1String("application/x-rar-compressed"), NFO::Archive() ); typeMapper.insert( QLatin1String("application/x-stuffit"), NFO::Archive() ); typeMapper.insert( QLatin1String("application/x-stuffitx"), NFO::Archive() ); typeMapper.insert( QLatin1String("application/x-gtar"), NFO::Archive() ); typeMapper.insert( QLatin1String("application/zip"), NFO::Archive() ); // Special images typeMapper.insert( QLatin1String("image/vnd.microsoft.icon"), NFO::Icon() ); typeMapper.insert( QLatin1String("image/svg+xml"), NFO::VectorImage() ); // Fonts typeMapper.insert( QLatin1String("application/vnd.ms-fontobject"), NFO::Font() ); typeMapper.insert( QLatin1String("application/vnd.ms-opentype"), NFO::Font() ); } QHash< QString, QUrl >::const_iterator it = typeMapper.constFind( mimeType ); if( it != typeMapper.constEnd() ) types << it.value(); return types; }
bool OsmAnd::MapObjectsSymbolsProvider_P::obtainData( const TileId tileId, const ZoomLevel zoom, std::shared_ptr<MapObjectsSymbolsProvider::Data>& outTiledData, const IQueryController* const queryController, const FilterCallback filterCallback) { const auto tileBBox31 = Utilities::tileBoundingBox31(tileId, zoom); // Obtain offline map primitives tile std::shared_ptr<IMapTiledDataProvider::Data> primitivesTile_; owner->primitivesProvider->obtainData(tileId, zoom, primitivesTile_); const auto primitivesTile = std::static_pointer_cast<MapPrimitivesProvider::Data>(primitivesTile_); // If tile has nothing to be rasterized, mark that data is not available for it if (!primitivesTile_ || primitivesTile->primitivisedObjects->isEmpty()) { // Mark tile as empty outTiledData.reset(); return true; } // Rasterize symbols and create symbols groups QList< std::shared_ptr<const SymbolRasterizer::RasterizedSymbolsGroup> > rasterizedSymbolsGroups; QHash< std::shared_ptr<const MapObject>, std::shared_ptr<MapObjectSymbolsGroup> > preallocatedSymbolsGroups; const auto rasterizationFilter = [this, tileBBox31, filterCallback, &preallocatedSymbolsGroups] (const std::shared_ptr<const MapObject>& mapObject) -> bool { const std::shared_ptr<MapObjectSymbolsGroup> preallocatedGroup(new MapObjectSymbolsGroup(mapObject)); if (!filterCallback || filterCallback(owner, preallocatedGroup)) { preallocatedSymbolsGroups.insert(mapObject, qMove(preallocatedGroup)); return true; } return false; }; owner->symbolRasterizer->rasterize( primitivesTile->primitivisedObjects, rasterizedSymbolsGroups, owner->symbolsScaleFactor, rasterizationFilter, nullptr); // Convert results auto& mapSymbolIntersectionClassesRegistry = MapSymbolIntersectionClassesRegistry::globalInstance(); QList< std::shared_ptr<MapSymbolsGroup> > symbolsGroups; for (const auto& rasterizedGroup : constOf(rasterizedSymbolsGroups)) { const auto& mapObject = rasterizedGroup->mapObject; ////////////////////////////////////////////////////////////////////////// //if ((mapObject->id >> 1) == 189600735u) //{ // int i = 5; //} ////////////////////////////////////////////////////////////////////////// // Get preallocated group const auto citPreallocatedGroup = preallocatedSymbolsGroups.constFind(mapObject); assert(citPreallocatedGroup != preallocatedSymbolsGroups.cend()); const auto group = *citPreallocatedGroup; // Create shareable path const std::shared_ptr< const QVector<PointI> > shareablePath31(new QVector<PointI>(mapObject->points31)); // Convert all symbols inside group bool hasAtLeastOneOnPath = false; bool hasAtLeastOneAlongPathBillboard = false; bool hasAtLeastOneSimpleBillboard = false; for (const auto& rasterizedSymbol : constOf(rasterizedGroup->symbols)) { assert(static_cast<bool>(rasterizedSymbol->bitmap)); std::shared_ptr<MapSymbol> symbol; if (const auto rasterizedSpriteSymbol = std::dynamic_pointer_cast<const SymbolRasterizer::RasterizedSpriteSymbol>(rasterizedSymbol)) { if (!hasAtLeastOneAlongPathBillboard && rasterizedSpriteSymbol->drawAlongPath) hasAtLeastOneAlongPathBillboard = true; if (!hasAtLeastOneSimpleBillboard && !rasterizedSpriteSymbol->drawAlongPath) hasAtLeastOneSimpleBillboard = true; const auto billboardRasterSymbol = new BillboardRasterMapSymbol(group); billboardRasterSymbol->order = rasterizedSpriteSymbol->order; billboardRasterSymbol->bitmap = rasterizedSpriteSymbol->bitmap; billboardRasterSymbol->size = PointI(rasterizedSpriteSymbol->bitmap->width(), rasterizedSpriteSymbol->bitmap->height()); billboardRasterSymbol->content = rasterizedSpriteSymbol->content; billboardRasterSymbol->languageId = rasterizedSpriteSymbol->languageId; billboardRasterSymbol->minDistance = rasterizedSpriteSymbol->minDistance; billboardRasterSymbol->position31 = rasterizedSpriteSymbol->location31; billboardRasterSymbol->offset = rasterizedSpriteSymbol->offset; if (rasterizedSpriteSymbol->intersectionBBox.width() > 0 || rasterizedSpriteSymbol->intersectionBBox.height() > 0) { const auto halfWidth = billboardRasterSymbol->size.x / 2; const auto halfHeight = billboardRasterSymbol->size.y / 2; billboardRasterSymbol->margin.top() = -rasterizedSpriteSymbol->intersectionBBox.top() - halfHeight; billboardRasterSymbol->margin.left() = -rasterizedSpriteSymbol->intersectionBBox.left() - halfWidth; billboardRasterSymbol->margin.bottom() = rasterizedSpriteSymbol->intersectionBBox.bottom() - halfHeight; billboardRasterSymbol->margin.right() = rasterizedSpriteSymbol->intersectionBBox.right() - halfWidth; // Collect intersection classes for (const auto& intersectsWithClass : constOf(rasterizedSpriteSymbol->primitiveSymbol->intersectsWith)) { billboardRasterSymbol->intersectsWithClasses.insert(mapSymbolIntersectionClassesRegistry.getOrRegisterClassIdByName(intersectsWithClass)); } } billboardRasterSymbol->pathPaddingLeft = rasterizedSpriteSymbol->pathPaddingLeft; billboardRasterSymbol->pathPaddingRight = rasterizedSpriteSymbol->pathPaddingRight; symbol.reset(billboardRasterSymbol); } else if (const auto rasterizedOnPathSymbol = std::dynamic_pointer_cast<const SymbolRasterizer::RasterizedOnPathSymbol>(rasterizedSymbol)) { hasAtLeastOneOnPath = true; const auto onPathSymbol = new OnPathRasterMapSymbol(group); onPathSymbol->order = rasterizedOnPathSymbol->order; onPathSymbol->bitmap = rasterizedOnPathSymbol->bitmap; onPathSymbol->size = PointI(rasterizedOnPathSymbol->bitmap->width(), rasterizedOnPathSymbol->bitmap->height()); onPathSymbol->content = rasterizedOnPathSymbol->content; onPathSymbol->languageId = rasterizedOnPathSymbol->languageId; onPathSymbol->minDistance = rasterizedOnPathSymbol->minDistance; onPathSymbol->shareablePath31 = shareablePath31; assert(shareablePath31->size() >= 2); onPathSymbol->glyphsWidth = rasterizedOnPathSymbol->glyphsWidth; for (const auto& intersectsWithClass : constOf(rasterizedOnPathSymbol->primitiveSymbol->intersectsWith)) { onPathSymbol->intersectsWithClasses.insert(mapSymbolIntersectionClassesRegistry.getOrRegisterClassIdByName(intersectsWithClass)); } onPathSymbol->pathPaddingLeft = rasterizedOnPathSymbol->pathPaddingLeft; onPathSymbol->pathPaddingRight = rasterizedOnPathSymbol->pathPaddingRight; symbol.reset(onPathSymbol); } else { LogPrintf(LogSeverityLevel::Error, "MapObject %s produced unsupported symbol type", qPrintable(mapObject->toString())); } if (rasterizedSymbol->contentType == SymbolRasterizer::RasterizedSymbol::ContentType::Icon) symbol->contentClass = MapSymbol::ContentClass::Icon; else if (rasterizedSymbol->contentType == SymbolRasterizer::RasterizedSymbol::ContentType::Text) symbol->contentClass = MapSymbol::ContentClass::Caption; group->symbols.push_back(qMove(symbol)); } // If there's at least one on-path symbol or along-path symbol, this group needs special post-processing: // - Compute pin-points for all symbols in group (including billboard ones) // - Split path between them if (hasAtLeastOneOnPath || hasAtLeastOneAlongPathBillboard) { ////////////////////////////////////////////////////////////////////////// //if ((mapObject->id >> 1) == 7381701u) //{ // int i = 5; //} ////////////////////////////////////////////////////////////////////////// // Compose list of symbols to compute pin-points for QList<SymbolForPinPointsComputation> symbolsForComputation; symbolsForComputation.reserve(group->symbols.size()); for (const auto& symbol : constOf(group->symbols)) { if (const auto billboardSymbol = std::dynamic_pointer_cast<BillboardRasterMapSymbol>(symbol)) { // Get larger bbox, to take into account possible rotation const auto maxSize = qMax(billboardSymbol->size.x, billboardSymbol->size.y); const auto outerCircleRadius = 0.5f * static_cast<float>(qSqrt(2 * maxSize * maxSize)); symbolsForComputation.push_back({ billboardSymbol->pathPaddingLeft, 2.0f * outerCircleRadius, billboardSymbol->pathPaddingRight }); } else if (const auto onPathSymbol = std::dynamic_pointer_cast<OnPathRasterMapSymbol>(symbol)) { symbolsForComputation.push_back({ onPathSymbol->pathPaddingLeft, static_cast<float>(onPathSymbol->size.x), onPathSymbol->pathPaddingRight }); } } const auto& env = owner->primitivesProvider->primitiviser->environment; float globalLeftPaddingInPixels = 0.0f; float globalRightPaddingInPixels = 0.0f; env->obtainGlobalPathPadding(globalLeftPaddingInPixels, globalRightPaddingInPixels); const auto globalSpacingBetweenBlocksInPixels = env->getGlobalPathSymbolsBlockSpacing(); const auto computedPinPointsByLayer = computePinPoints( mapObject->points31, globalLeftPaddingInPixels, // global left padding in pixels globalRightPaddingInPixels, // global right padding in pixels globalSpacingBetweenBlocksInPixels, // global spacing between blocks in pixels symbolsForComputation, mapObject->getMinZoomLevel(), mapObject->getMaxZoomLevel(), zoom); // After pin-points were computed, assign them to symbols in the same order for (const auto& computedPinPoints : constOf(computedPinPointsByLayer)) { auto citComputedPinPoint = computedPinPoints.cbegin(); const auto citComputedPinPointsEnd = computedPinPoints.cend(); while (citComputedPinPoint != citComputedPinPointsEnd) { // Construct new additional instance of group std::shared_ptr<MapSymbolsGroup::AdditionalInstance> additionalGroupInstance(new MapSymbolsGroup::AdditionalInstance(group)); for (const auto& symbol : constOf(group->symbols)) { // Stop in case no more pin-points left if (citComputedPinPoint == citComputedPinPointsEnd) break; const auto& computedPinPoint = *(citComputedPinPoint++); std::shared_ptr<MapSymbolsGroup::AdditionalSymbolInstanceParameters> additionalSymbolInstance; if (const auto billboardSymbol = std::dynamic_pointer_cast<BillboardRasterMapSymbol>(symbol)) { const auto billboardSymbolInstance = new MapSymbolsGroup::AdditionalBillboardSymbolInstanceParameters(additionalGroupInstance.get()); billboardSymbolInstance->overridesPosition31 = true; billboardSymbolInstance->position31 = computedPinPoint.point31; additionalSymbolInstance.reset(billboardSymbolInstance); } else if (const auto onPathSymbol = std::dynamic_pointer_cast<OnPathRasterMapSymbol>(symbol)) { IOnPathMapSymbol::PinPoint pinPoint; pinPoint.point31 = computedPinPoint.point31; pinPoint.basePathPointIndex = computedPinPoint.basePathPointIndex; pinPoint.offsetFromBasePathPoint31 = computedPinPoint.offsetFromBasePathPoint31; pinPoint.normalizedOffsetFromBasePathPoint = computedPinPoint.normalizedOffsetFromBasePathPoint; const auto onPathSymbolInstance = new MapSymbolsGroup::AdditionalOnPathSymbolInstanceParameters(additionalGroupInstance.get()); onPathSymbolInstance->overridesPinPointOnPath = true; onPathSymbolInstance->pinPointOnPath = pinPoint; additionalSymbolInstance.reset(onPathSymbolInstance); } if (additionalSymbolInstance) additionalGroupInstance->symbols.insert(symbol, qMove(additionalSymbolInstance)); } group->additionalInstances.push_back(qMove(additionalGroupInstance)); } } // This group needs intersection check inside group group->intersectionProcessingMode |= MapSymbolsGroup::IntersectionProcessingModeFlag::CheckIntersectionsWithinGroup; // Finally there's no need in original, so turn it off group->additionalInstancesDiscardOriginal = true; } // Configure group if (!group->symbols.isEmpty()) { if (hasAtLeastOneSimpleBillboard && !(hasAtLeastOneOnPath || hasAtLeastOneAlongPathBillboard)) { group->presentationMode |= MapSymbolsGroup::PresentationModeFlag::ShowNoneIfIconIsNotShown; group->presentationMode |= MapSymbolsGroup::PresentationModeFlag::ShowAnythingUntilFirstGap; } else if (!hasAtLeastOneSimpleBillboard && (hasAtLeastOneOnPath || hasAtLeastOneAlongPathBillboard)) { group->presentationMode |= MapSymbolsGroup::PresentationModeFlag::ShowAnything; } else { LogPrintf(LogSeverityLevel::Error, "%s produced incompatible set of map symbols to compute presentation mode", qPrintable(group->toString())); group->presentationMode |= MapSymbolsGroup::PresentationModeFlag::ShowAnything; } } // Add constructed group to output symbolsGroups.push_back(qMove(group)); } // Create output tile outTiledData.reset(new MapObjectsSymbolsProvider::Data( tileId, zoom, symbolsGroups, primitivesTile, new RetainableCacheMetadata(primitivesTile->retainableCacheMetadata))); return true; }