bool OsmAnd::MapMarker_P::applyChanges()
{
QReadLocker scopedLocker1(&_lock);
if (!_hasUnappliedChanges)
return false;
QReadLocker scopedLocker2(&_symbolsGroupsRegistryLock);
for (const auto& symbolGroup_ : constOf(_symbolsGroupsRegistry))
{
const auto symbolGroup = symbolGroup_.lock();
if (!symbolGroup)
continue;
for (const auto& symbol_ : constOf(symbolGroup->symbols))
{
symbol_->isHidden = _isHidden;
if (const auto symbol = std::dynamic_pointer_cast<AccuracyCircleMapSymbol>(symbol_))
{
symbol->setPosition31(_position);
symbol->isHidden = _isHidden || !_isAccuracyCircleVisible;
symbol->scale = _accuracyCircleRadius;
}
if (const auto symbol = std::dynamic_pointer_cast<BillboardRasterMapSymbol>(symbol_))
{
symbol->setPosition31(_position);
symbol->modulationColor = _pinIconModulationColor;
}
if (const auto symbol = std::dynamic_pointer_cast<KeyedOnSurfaceRasterMapSymbol>(symbol_))
{
symbol->setPosition31(_position);
const auto citDirection = _directions.constFind(symbol->key);
if (citDirection != _directions.cend())
symbol->direction = *citDirection;
}
}
}
_hasUnappliedChanges = false;
return true;
}
void OsmAnd::ObfsCollection_P::collectSources() const
{
QWriteLocker scopedLocker1(&_collectedSourcesLock);
QReadLocker scopedLocker2(&_sourcesOriginsLock);
// Capture how many invalidations are going to be processed
const auto invalidationsToProcess = _collectedSourcesInvalidated.loadAcquire();
if (invalidationsToProcess == 0)
return;
#if OSMAND_DEBUG
const auto collectSources_Begin = std::chrono::high_resolution_clock::now();
#endif
// Check all previously collected sources
auto itCollectedSourcesEntry = mutableIteratorOf(_collectedSources);
while(itCollectedSourcesEntry.hasNext())
{
const auto& collectedSourcesEntry = itCollectedSourcesEntry.next();
const auto& originId = collectedSourcesEntry.key();
auto& collectedSources = collectedSourcesEntry.value();
const auto& itSourceOrigin = _sourcesOrigins.constFind(originId);
// If current source origin was removed,
// remove entire each collected source related to it
if (itSourceOrigin == _sourcesOrigins.cend())
{
// Ensure that ObfFile is not being read anywhere
for(const auto& itCollectedSource : rangeOf(collectedSources))
{
const auto obfFile = itCollectedSource.value();
//NOTE: OBF should have been locked here, but since file is gone anyways, this lock is quite useless
itCollectedSource.value().reset();
assert(obfFile.use_count() == 1);
}
itCollectedSourcesEntry.remove();
continue;
}
// Check for missing files
auto itObfFileEntry = mutableIteratorOf(collectedSources);
while(itObfFileEntry.hasNext())
{
const auto& sourceFilename = itObfFileEntry.next().key();
if (QFile::exists(sourceFilename))
continue;
const auto obfFile = itObfFileEntry.value();
//NOTE: OBF should have been locked here, but since file is gone anyways, this lock is quite useless
itObfFileEntry.remove();
assert(obfFile.use_count() == 1);
}
// If all collected sources for current source origin are gone,
// remove entire collection attached to source origin ID
if (collectedSources.isEmpty())
{
itCollectedSourcesEntry.remove();
continue;
}
}
// Find all files uncollected sources
for(const auto& itEntry : rangeOf(constOf(_sourcesOrigins)))
{
const auto& originId = itEntry.key();
const auto& entry = itEntry.value();
auto itCollectedSources = _collectedSources.find(originId);
if (itCollectedSources == _collectedSources.end())
itCollectedSources = _collectedSources.insert(originId, QHash<QString, std::shared_ptr<ObfFile> >());
auto& collectedSources = *itCollectedSources;
if (entry->type == SourceOriginType::Directory)
{
const auto& directoryAsSourceOrigin = std::static_pointer_cast<const DirectoryAsSourceOrigin>(entry);
QFileInfoList obfFilesInfo;
Utilities::findFiles(directoryAsSourceOrigin->directory, QStringList() << QLatin1String("*.obf"), obfFilesInfo, directoryAsSourceOrigin->isRecursive);
for(const auto& obfFileInfo : constOf(obfFilesInfo))
{
const auto& obfFilePath = obfFileInfo.canonicalFilePath();
if (collectedSources.constFind(obfFilePath) != collectedSources.cend())
continue;
auto obfFile = new ObfFile(obfFilePath, obfFileInfo.size());
collectedSources.insert(obfFilePath, std::shared_ptr<ObfFile>(obfFile));
}
if (directoryAsSourceOrigin->isRecursive)
{
QFileInfoList directoriesInfo;
Utilities::findDirectories(directoryAsSourceOrigin->directory, QStringList() << QLatin1String("*"), directoriesInfo, true);
for(const auto& directoryInfo : constOf(directoriesInfo))
{
const auto canonicalPath = directoryInfo.canonicalFilePath();
if (directoryAsSourceOrigin->watchedSubdirectories.contains(canonicalPath))
continue;
_fileSystemWatcher->addPath(canonicalPath);
directoryAsSourceOrigin->watchedSubdirectories.insert(canonicalPath);
}
}
}
else if (entry->type == SourceOriginType::File)
{
const auto& fileAsSourceOrigin = std::static_pointer_cast<const FileAsSourceOrigin>(entry);
if (!fileAsSourceOrigin->fileInfo.exists())
continue;
const auto& obfFilePath = fileAsSourceOrigin->fileInfo.canonicalFilePath();
if (collectedSources.constFind(obfFilePath) != collectedSources.cend())
continue;
auto obfFile = new ObfFile(obfFilePath, fileAsSourceOrigin->fileInfo.size());
collectedSources.insert(obfFilePath, std::shared_ptr<ObfFile>(obfFile));
}
}
// Decrement invalidations counter with number of processed onces
_collectedSourcesInvalidated.fetchAndAddOrdered(-invalidationsToProcess);
#if OSMAND_DEBUG
const auto collectSources_End = std::chrono::high_resolution_clock::now();
const std::chrono::duration<float> collectSources_Elapsed = collectSources_End - collectSources_Begin;
LogPrintf(LogSeverityLevel::Info, "Collected OBF sources in %fs", collectSources_Elapsed.count());
#endif
}