void tst_QAtomicIntegerXX::assign()
{
QFETCH(LargeInt, value);
QAtomicInteger<T> atomic(value);
QAtomicInteger<T> copy;
copy = atomic;
QCOMPARE(copy.load(), atomic.load());
QAtomicInteger<T> copy2;
copy2 = atomic; // operator=(const QAtomicInteger &)
QCOMPARE(copy2.load(), atomic.load());
QAtomicInteger<T> copy2bis;
copy2bis = atomic.load(); // operator=(T)
QCOMPARE(copy2bis.load(), atomic.load());
// move
QAtomicInteger<T> copy3;
copy3 = qMove(copy);
QCOMPARE(copy3.load(), atomic.load());
QAtomicInteger<T> copy4;
copy4 = qMove(copy2);
QCOMPARE(copy4.load(), atomic.load());
}
void tst_QPen::move_assign()
{
QPen p1(Qt::black), p2(Qt::white);
// check that moving does the right thing:
p2 = qMove(p1); // could be move or copy assignment, so don't check p1's state
QCOMPARE(p2.color(), QColor(Qt::black));
// check that move-assigned-from QPen p1 can still be used, albeit
// with undocumented state (it's p2's original state):
QVERIFY(p1.style() != Qt::NoPen);
// check that moved-from QPen p1 can still be safely copied:
const QPen p3 = p1;
// check that moved-from QPen p1 can still be safely assigned to:
const QPen p4(Qt::yellow);
p1 = p4;
QCOMPARE(p1.color(), QColor(Qt::yellow));
// check that moved-from QPens p2, p3 can still be safely destroyed:
QPen p5;
p5 = qMove(p2);
// intentionally no more statements beyond this point
}
void tst_QPalette::moveSemantics()
{
#ifdef Q_COMPILER_RVALUE_REFS
QPalette src(Qt::red), dst;
const QPalette control = src;
QVERIFY(src != dst);
QCOMPARE(src, control);
QVERIFY(!dst.isCopyOf(src));
QVERIFY(!dst.isCopyOf(control));
dst = qMove(src); // move assignment
QVERIFY(!dst.isCopyOf(src)); // isCopyOf() works on moved-from palettes, too
QVERIFY(dst.isCopyOf(control));
QCOMPARE(dst, control);
src = control; // check moved-from 'src' can still be assigned to (doesn't crash)
QVERIFY(src.isCopyOf(dst));
QVERIFY(src.isCopyOf(control));
QPalette dst2(qMove(src)); // move construction
QVERIFY(!src.isCopyOf(dst));
QVERIFY(!src.isCopyOf(dst2));
QVERIFY(!src.isCopyOf(control));
QCOMPARE(dst2, control);
QVERIFY(dst2.isCopyOf(dst));
QVERIFY(dst2.isCopyOf(control));
// check moved-from 'src' can still be destroyed (doesn't crash)
#else
QSKIP("Compiler doesn't support C++11 move semantics");
#endif
}
bool OsmAnd::MapRendererKeyedSymbolsResource::uploadToGPU()
{
bool ok;
bool anyUploadFailed = false;
const auto link_ = link.lock();
const auto collection = static_cast<MapRendererKeyedResourcesCollection*>(&link_->collection);
QHash< std::shared_ptr<MapSymbol>, std::shared_ptr<const GPUAPI::ResourceInGPU> > uploaded;
for (const auto& symbol : constOf(_sourceData->symbolsGroup->symbols))
{
// Prepare data and upload to GPU
std::shared_ptr<const GPUAPI::ResourceInGPU> resourceInGPU;
ok = resourcesManager->uploadSymbolToGPU(symbol, resourceInGPU);
// If upload have failed, stop
if (!ok)
{
LogPrintf(LogSeverityLevel::Error, "Failed to upload keyed symbol");
anyUploadFailed = true;
break;
}
// Mark this symbol as uploaded
uploaded.insert(symbol, qMove(resourceInGPU));
}
// If at least one symbol failed to upload, consider entire tile as failed to upload,
// and unload its partial GPU resources
if (anyUploadFailed)
{
uploaded.clear();
return false;
}
// All resources have been uploaded to GPU successfully by this point
_retainableCacheMetadata = _sourceData->retainableCacheMetadata;
_sourceData.reset();
for (const auto& entry : rangeOf(constOf(uploaded)))
{
const auto& symbol = entry.key();
auto& resource = entry.value();
// Unload GPU data from symbol, since it's uploaded already
resourcesManager->releaseGpuUploadableDataFrom(symbol);
// Move reference
_resourcesInGPU.insert(symbol, qMove(resource));
}
return true;
}
OSMAND_CORE_API QString OSMAND_CORE_CALL OsmAnd::ICU::transliterateToLatin(
const QString& input,
const bool keepAccentsAndDiacriticsInInput /*= true*/,
const bool keepAccentsAndDiacriticsInOutput /*= true*/)
{
QString output;
UErrorCode icuError = U_ZERO_ERROR;
bool ok = true;
const auto pAnyToLatinTransliterator = g_pIcuAnyToLatinTransliterator->clone();
if (pAnyToLatinTransliterator == nullptr || U_FAILURE(icuError))
{
LogPrintf(LogSeverityLevel::Error, "ICU error: %d", icuError);
if (pAnyToLatinTransliterator != nullptr)
delete pAnyToLatinTransliterator;
return input;
}
// Transliterate from any to latin
UnicodeString icuString(reinterpret_cast<const UChar*>(input.unicode()), input.length());
pAnyToLatinTransliterator->transliterate(icuString);
output = qMove(QString(reinterpret_cast<const QChar*>(icuString.getBuffer()), icuString.length()));
// If input and output differ at this point or accents/diacritics should be converted,
// normalize the output again
if ((input.compare(output, Qt::CaseInsensitive) != 0 || !keepAccentsAndDiacriticsInInput) && !keepAccentsAndDiacriticsInOutput)
{
const auto pIcuAccentsAndDiacriticsConverter = g_pIcuAccentsAndDiacriticsConverter->clone();
ok = pIcuAccentsAndDiacriticsConverter != nullptr && U_SUCCESS(icuError);
if (ok)
{
pIcuAccentsAndDiacriticsConverter->transliterate(icuString);
output = qMove(QString(reinterpret_cast<const QChar*>(icuString.getBuffer()), icuString.length()));
}
if (pIcuAccentsAndDiacriticsConverter != nullptr)
delete pIcuAccentsAndDiacriticsConverter;
}
if (pAnyToLatinTransliterator != nullptr)
delete pAnyToLatinTransliterator;
if (!ok)
{
LogPrintf(LogSeverityLevel::Error, "ICU error: %d", icuError);
return input;
}
return output;
}
std::shared_ptr<OsmAnd::ObfDataInterface> OsmAnd::ObfsCollection_P::obtainDataInterface() const
{
// Check if sources were invalidated
if (_collectedSourcesInvalidated.loadAcquire() > 0)
collectSources();
// Create ObfReaders from collected sources
QList< std::shared_ptr<const ObfReader> > obfReaders;
{
QReadLocker scopedLocker(&_collectedSourcesLock);
for(const auto& collectedSources : constOf(_collectedSources))
{
obfReaders.reserve(obfReaders.size() + collectedSources.size());
for(const auto& obfFile : constOf(collectedSources))
{
std::shared_ptr<const ObfReader> obfReader(new ObfReader(obfFile));
if (!obfReader->isOpened() || !obfReader->obtainInfo())
continue;
obfReaders.push_back(qMove(obfReader));
}
}
}
return std::shared_ptr<ObfDataInterface>(new ObfDataInterface(obfReaders));
}
OsmAnd::ObfsCollection::SourceOriginId OsmAnd::ObfsCollection_P::addDirectory(const QDir& dir, bool recursive)
{
QWriteLocker scopedLocker(&_sourcesOriginsLock);
const auto allocatedId = _lastUnusedSourceOriginId++;
auto sourceOrigin = new DirectoryAsSourceOrigin();
sourceOrigin->directory = dir;
sourceOrigin->isRecursive = recursive;
_sourcesOrigins.insert(allocatedId, qMove(std::shared_ptr<const SourceOrigin>(sourceOrigin)));
_fileSystemWatcher->addPath(dir.canonicalPath());
if (recursive)
{
QFileInfoList subdirs;
Utilities::findDirectories(dir, QStringList() << QLatin1String("*"), subdirs, true);
for(const auto& subdir : subdirs)
{
const auto canonicalPath = subdir.canonicalFilePath();
sourceOrigin->watchedSubdirectories.insert(canonicalPath);
_fileSystemWatcher->addPath(canonicalPath);
}
}
invalidateCollectedSources();
return allocatedId;
}
/*!
\fn QVersionNumber QVersionNumber::fromString(const QString &string,
int *suffixIndex)
Constructs a QVersionNumber from a specially formatted \a string of
non-negative decimal numbers delimited by '.'.
Once the numerical segments have been parsed, the remainder of the string
is considered to be the suffix string. The start index of that string will be
stored in \a suffixIndex if it is not null.
\snippet qversionnumber/main.cpp 3
\sa isNull()
*/
QVersionNumber QVersionNumber::fromString(const QString &string, int *suffixIndex)
{
QVector<int> seg;
const QByteArray cString(string.toLatin1());
const char *start = cString.constData();
const char *end = start;
const char *lastGoodEnd = start;
const char *endOfString = cString.constData() + cString.size();
do {
bool ok = false;
const qulonglong value = qstrtoull(start, &end, 10, &ok);
if (!ok || value > qulonglong(std::numeric_limits<int>::max()))
break;
seg.append(int(value));
start = end + 1;
lastGoodEnd = end;
} while (start < endOfString && (end < endOfString && *end == '.'));
if (suffixIndex)
*suffixIndex = int(lastGoodEnd - cString.constData());
return QVersionNumber(qMove(seg));
}
bool OsmAnd::MapStyle_P::registerRule( MapStyleRulesetType type, const std::shared_ptr<MapStyleRule>& rule )
{
MapStyleValue tagData;
if(!rule->getAttribute(_builtinValueDefs->INPUT_TAG, tagData))
{
OsmAnd::LogPrintf(OsmAnd::LogSeverityLevel::Error, "Attribute tag should be specified for root filter");
return false;
}
MapStyleValue valueData;
if(!rule->getAttribute(_builtinValueDefs->INPUT_VALUE, valueData))
{
OsmAnd::LogPrintf(OsmAnd::LogSeverityLevel::Error, "Attribute tag should be specified for root filter");
return false;
}
uint64_t id = encodeRuleId(tagData.asSimple.asUInt, valueData.asSimple.asUInt);
auto insertedRule = rule;
auto& ruleset = obtainRulesRef(type);
auto itPrevious = ruleset.constFind(id);
if(itPrevious != ruleset.cend())
{
// all root rules should have at least tag/value
insertedRule = createTagValueRootWrapperRule(id, *itPrevious);
insertedRule->_d->_ifElseChildren.push_back(rule);
}
ruleset.insert(id, qMove(insertedRule));
return true;
}
void MachineModel::specialMoveY(const float& y, const float& feed)
{
FloatPoint sp = localPosition;
sp.y = y;
sp.f = feed;
qMove(sp);
}
bool OsmAnd::MapRendererTiledResourcesCollection::updateCollectionSnapshot() const
{
const auto invalidatesDiscarded = _collectionSnapshotInvalidatesCount.fetchAndAddOrdered(0);
if (invalidatesDiscarded == 0)
return true;
// Copy from original storage to temp storage
Storage storageCopy;
{
if (!_collectionLock.tryLockForRead())
return false;
for (int zoomLevel = MinZoomLevel; zoomLevel <= MaxZoomLevel; zoomLevel++)
{
const auto& sourceStorageLevel = constOf(_storage)[zoomLevel];
auto& targetStorageLevel = storageCopy[zoomLevel];
targetStorageLevel = detachedOf(sourceStorageLevel);
}
_collectionLock.unlock();
}
_collectionSnapshotInvalidatesCount.fetchAndAddOrdered(-invalidatesDiscarded);
// Copy from temp storage to snapshot
{
QWriteLocker scopedLocker(&_snapshot->_lock);
_snapshot->_storage = qMove(storageCopy);
}
return true;
}
void OsmAnd::ICU::initialize()
{
// Initialize ICU
UErrorCode icuError = U_ZERO_ERROR;
g_IcuData = qMove(std::unique_ptr<QByteArray>(new QByteArray(EmbeddedResources::decompressResource(QLatin1String("icu4c/icu-data-l.dat")))));
udata_setCommonData(g_IcuData->constData(), &icuError);
if (U_FAILURE(icuError))
{
LogPrintf(LogSeverityLevel::Error, "Failed to initialize ICU data: %d", icuError);
return;
}
u_init(&icuError);
if (U_FAILURE(icuError))
{
LogPrintf(LogSeverityLevel::Error, "Failed to initialize ICU: %d", icuError);
return;
}
// Allocate resources:
g_pIcuAnyToLatinTransliterator = Transliterator::createInstance(UnicodeString("Any-Latin/BGN"), UTRANS_FORWARD, icuError);
if (U_FAILURE(icuError))
LogPrintf(LogSeverityLevel::Error, "Failed to create global ICU Any-to-Latin transliterator: %d", icuError);
icuError = U_ZERO_ERROR;
g_pIcuAccentsAndDiacriticsConverter = Transliterator::createInstance(UnicodeString("NFD; [:Mn:] Remove; NFC"), UTRANS_FORWARD, icuError);
if (U_FAILURE(icuError))
LogPrintf(LogSeverityLevel::Error, "Failed to create global ICU accents&diacritics converter: %d", icuError);
icuError = U_ZERO_ERROR;
g_pIcuWordBreakIterator = BreakIterator::createWordInstance(Locale::getRoot(), icuError);
if (U_FAILURE(icuError))
LogPrintf(LogSeverityLevel::Error, "Failed to create global ICU word break iterator: %d", icuError);
}
OSMAND_CORE_API QString OSMAND_CORE_CALL OsmAnd::ICU::transliterateToLatin(const QString& input)
{
QString output;
UErrorCode icuError = U_ZERO_ERROR;
bool ok = true;
const auto pTransliterator = g_pIcuTransliterator->clone();
if(pTransliterator == nullptr || !U_SUCCESS(icuError))
{
LogPrintf(LogSeverityLevel::Error, "ICU error: %d", icuError);
if(pTransliterator != nullptr)
delete pTransliterator;
return input;
}
UnicodeString icuString(reinterpret_cast<const UChar*>(input.unicode()), input.length());
pTransliterator->transliterate(icuString);
output = qMove(QString(reinterpret_cast<const QChar*>(icuString.getBuffer()), icuString.length()));
if(pTransliterator != nullptr)
delete pTransliterator;
if(!ok)
{
LogPrintf(LogSeverityLevel::Error, "ICU error: %d", icuError);
return input;
}
return output;
}
void MachineModel::specialMoveZ(const float& z, const float& feed)
{
FloatPoint sp = localPosition;
sp.z = z;
sp.f = feed;
qMove(sp);
}
void TexturePacker::pack()
{
QString basepath = Project::getActiveProject().getImagePath();
SpriteArray sprites, usedSprites;
recurseDirectory(sprites, basepath);
SpriteAtlas& atlas = Project::getActiveProject().getSpriteAtlas();
atlas.clear();
do
{
MaxRectsAlgorithm maxrects(2046, 2046);
maxrects.insert(sprites, usedSprites);
if ( !usedSprites.isEmpty() )
{
SpriteSheet sheet = createSpriteSheet(usedSprites);
atlas.append(qMove(sheet));
usedSprites.clear();
}
}
while ( !sprites.isEmpty() );
atlas.save(Project::getActiveProject().getTileAtlasPath());
}
QList< std::shared_ptr<const OsmAnd::Road> > OsmAnd::CachingRoadLocator_P::findRoadsInArea(
const PointI position31,
const double radiusInMeters,
const RoutingDataLevel dataLevel) const
{
QList< std::shared_ptr<const Road> > roadsInBBox;
const auto bbox31 = (AreaI)Utilities::boundingBox31FromAreaInMeters(radiusInMeters, position31);
const auto obfDataInterface = owner->obfsCollection->obtainDataInterface(bbox31);
QList< std::shared_ptr<const ObfRoutingSectionReader::DataBlock> > referencedCacheEntries;
obfDataInterface->loadRoads(
dataLevel,
&bbox31,
&roadsInBBox,
nullptr,
nullptr,
&_cache,
&referencedCacheEntries,
nullptr,
nullptr);
{
QMutexLocker scopedLocker(&_referencedDataBlocksMapMutex);
for (auto& referencedBlock : referencedCacheEntries)
_referencedDataBlocksMap[referencedBlock.get()].push_back(qMove(referencedBlock));
}
return RoadLocator::findRoadsInArea(roadsInBBox, position31, radiusInMeters);
}
void MachineModel::specialMoveX(const float& x, const float& feed)
{
FloatPoint sp = localPosition;
sp.x = x;
sp.f = feed;
qMove(sp);
}
void OsmAnd::ObfPoiSectionReader_P::readCategory( const ObfReader_P& reader, const std::shared_ptr<AmenityCategory>& category )
{
const auto cis = reader.getCodedInputStream().get();
for(;;)
{
const auto tag = cis->ReadTag();
switch(gpb::internal::WireFormatLite::GetTagFieldNumber(tag))
{
case 0:
if (!ObfReaderUtilities::reachedDataEnd(cis))
return;
return;
case OBF::OsmAndCategoryTable::kCategoryFieldNumber:
ObfReaderUtilities::readQString(cis, category->_name);
break;
case OBF::OsmAndCategoryTable::kSubcategoriesFieldNumber:
{
QString name;
if (ObfReaderUtilities::readQString(cis, name))
category->_subcategories.push_back(qMove(name));
}
break;
default:
ObfReaderUtilities::skipUnknownField(cis, tag);
break;
}
}
}
void OsmAnd::ObfRoutingSectionReader_P::readBorderLinePoints(
const std::unique_ptr<ObfReader_P>& reader,
QList< std::shared_ptr<const ObfRoutingBorderLinePoint> >* resultOut /*= nullptr*/,
IQueryFilter* filter /*= nullptr*/,
std::function<bool (const std::shared_ptr<const ObfRoutingBorderLinePoint>&)> visitor /*= nullptr*/
)
{
auto cis = reader->_codedInputStream.get();
PointI location;
gpb::uint64 id;
for(;;)
{
auto tag = cis->ReadTag();
switch(gpb::internal::WireFormatLite::GetTagFieldNumber(tag))
{
case 0:
return;
case OBF::OsmAndRoutingIndex_RouteBorderPointsBlock::kXFieldNumber:
cis->ReadVarint32(reinterpret_cast<gpb::uint32*>(&location.x));
break;
case OBF::OsmAndRoutingIndex_RouteBorderPointsBlock::kYFieldNumber:
cis->ReadVarint32(reinterpret_cast<gpb::uint32*>(&location.y));
break;
case OBF::OsmAndRoutingIndex_RouteBorderPointsBlock::kBaseIdFieldNumber:
cis->ReadVarint64(&id);
break;
case OBF::OsmAndRoutingIndex_RouteBorderPointsBlock::kPointsFieldNumber:
{
gpb::uint32 length;
cis->ReadVarint32(&length);
auto oldLimit = cis->PushLimit(length);
const std::shared_ptr<ObfRoutingBorderLinePoint> point(new ObfRoutingBorderLinePoint());
readBorderLinePoint(reader, point);
cis->PopLimit(oldLimit);
point->_id += id;
point->_location += location;
id = point->_id;
location = point->_location;
bool valid = true;
if(filter)
valid = filter->acceptsPoint(point->location);
if(valid && visitor)
valid = visitor(point);
if(valid && resultOut)
resultOut->push_back(qMove(point));
}
break;
default:
ObfReaderUtilities::skipUnknownField(cis, tag);
break;
}
}
}
bool OsmAnd::ResolvedMapStyle_P::mergeAndResolveParameters()
{
// Process styles chain in direct order, to exclude redefined parameters
auto citUnresolvedMapStyle = iteratorOf(owner->unresolvedMapStylesChain);
while (citUnresolvedMapStyle.hasNext())
{
const auto& unresolvedMapStyle = citUnresolvedMapStyle.next();
for (const auto& unresolvedParameter : constOf(unresolvedMapStyle->parameters))
{
const auto nameId = resolveStringIdInLUT(unresolvedParameter->name);
auto& resolvedParameter = _parameters[nameId];
// Skip already defined parameters
if (resolvedParameter)
continue;
// Resolve possible values
QList<MapStyleConstantValue> resolvedPossibleValues;
for (const auto& possibleValue : constOf(unresolvedParameter->possibleValues))
{
MapStyleConstantValue resolvedPossibleValue;
if (!parseConstantValue(possibleValue, unresolvedParameter->dataType, false, resolvedPossibleValue))
{
LogPrintf(LogSeverityLevel::Error,
"Failed to parse '%s' as possible value for '%s' (%s)",
qPrintable(possibleValue),
qPrintable(unresolvedParameter->name),
qPrintable(unresolvedParameter->title));
return false;
}
resolvedPossibleValues.push_back(qMove(resolvedPossibleValue));
}
// Create new resolved parameter
const std::shared_ptr<Parameter> newResolvedParameter(new Parameter(
unresolvedParameter->title,
unresolvedParameter->description,
unresolvedParameter->category,
nameId,
unresolvedParameter->dataType,
resolvedPossibleValues));
resolvedParameter = newResolvedParameter;
// Register parameter as value definition
const auto newValueDefId = _valuesDefinitions.size();
const std::shared_ptr<ParameterValueDefinition> inputValueDefinition(new ParameterValueDefinition(
newValueDefId,
unresolvedParameter->name,
newResolvedParameter));
_valuesDefinitions.push_back(inputValueDefinition);
_valuesDefinitionsIndicesByName.insert(unresolvedParameter->name, newValueDefId);
}
}
return true;
}
int SettingApp::readDefualtWidthIndent()
{
m_setting->beginGroup("settingSeptember");
m_setting->beginGroup("defaultWidthIndent");
int indent = m_setting->value("indent").toInt();
m_setting->endGroup();
m_setting->endGroup();
return qMove(indent);
}
int SettingApp::readDefualtWidthTab()
{
m_setting->beginGroup("settingSeptember");
m_setting->beginGroup("defaultWidthTab");
int tab = m_setting->value("tab").toInt();
m_setting->endGroup();
m_setting->endGroup();
return qMove(tab);
}
QString SettingApp::readDefaultSettingKey(const QString& group, const QString& name)
{
beginDefaultSchemeSettingKey();
m_setting->beginGroup(group);
QString key = m_setting->value(name).toString();
m_setting->endGroup();
endSetting();
return qMove(key);
}
QColor SettingApp::readDefaultSearchTextColorSettingSeptember()
{
beginDefaultColorSettingSeptember();
m_setting->beginGroup("searchTextColor");
QColor color = qvariant_cast<QColor>(m_setting->value("searchText"));
m_setting->endGroup();
endSetting();
return qMove(color);
}
QColor SettingApp::readDefaultCurrentLineColorSettingSeptember()
{
beginColorSettingSeptember();
m_setting->beginGroup("currentLineColor");
QColor color = qvariant_cast<QColor>(m_setting->value("currentLine"));
m_setting->endGroup();
endSetting();
return qMove(color);
}
bool SettingApp::readWarningChangeFileSeptember()
{
m_setting->beginGroup("settingSeptember");
m_setting->beginGroup("warningChangeFile");
bool value = m_setting->value("changeFile").toBool();
m_setting->endGroup();
m_setting->endGroup();
return qMove(value);
}
void tst_QAtomicIntegerXX::copy()
{
QFETCH(LargeInt, value);
QAtomicInteger<T> atomic(value);
QAtomicInteger<T> copy(atomic);
QCOMPARE(copy.load(), atomic.load());
QAtomicInteger<T> copy2 = atomic;
QCOMPARE(copy2.load(), atomic.load());
// move
QAtomicInteger<T> copy3(qMove(copy));
QCOMPARE(copy3.load(), atomic.load());
QAtomicInteger<T> copy4 = qMove(copy2);
QCOMPARE(copy4.load(), atomic.load());
}
QString SettingApp::readCurrentSchemeSettingSeptember()
{
m_setting->beginGroup("settingSeptember");
m_setting->beginGroup("currentScheme");
QString current = m_setting->value("name").toString();
m_setting->endGroup();
m_setting->endGroup();
return qMove(current);
}
QPair<QColor, QFont::Weight> SettingApp::readDefaultNumberQssSeptember()
{
beginDefaultQssSettingSeptember();
m_setting->beginGroup("numberQss");
QPair<QColor, QFont::Weight> pair = { qvariant_cast<QColor>(m_setting->value("color")),
static_cast<QFont::Weight>(m_setting->value("weight").toInt()) };
m_setting->endGroup();
endSetting();
return qMove(pair);
}
void OsmAnd::ObfRoutingSectionReader_P::readBorderBoxLinesHeaders(const std::unique_ptr<ObfReader_P>& reader,
QList< std::shared_ptr<const ObfRoutingBorderLineHeader> >* resultOut /*= nullptr*/,
IQueryFilter* filter /*= nullptr*/,
std::function<bool (const std::shared_ptr<const ObfRoutingBorderLineHeader>&)> visitor /*= nullptr*/)
{
auto cis = reader->_codedInputStream.get();
for(;;)
{
auto tag = cis->ReadTag();
switch(gpb::internal::WireFormatLite::GetTagFieldNumber(tag))
{
case 0:
return;
case OBF::OsmAndRoutingIndex_RouteBorderBox::kBorderLinesFieldNumber:
{
auto offset = cis->CurrentPosition();
gpb::uint32 length;
cis->ReadVarint32(&length);
auto oldLimit = cis->PushLimit(length);
const std::shared_ptr<ObfRoutingBorderLineHeader> line(new ObfRoutingBorderLineHeader());
readBorderLineHeader(reader, line, offset);
cis->PopLimit(oldLimit);
bool isValid = true;
if(filter)
{
if(line->_x2present)
isValid = filter->acceptsArea(AreaI(line->_x, line->_y, line->_x2, line->_y));
else
isValid = false;
/*FIXME: borders approach
else if(ln.hasToy())
isValid = req.intersects(ln.getX(), ln.getY(), ln.getX(), ln.getToy());*/
}
if(isValid)
{
if(!visitor || (visitor && visitor(line)))
{
if(resultOut)
resultOut->push_back(qMove(line));
}
}
}
break;
case OBF::OsmAndRoutingIndex_RouteBorderBox::kBlocksFieldNumber:
return;
default:
ObfReaderUtilities::skipUnknownField(cis, tag);
break;
}
}
}
