diff --git a/DataExtractionOSM/src/net/osmand/NativeLibrary.java b/DataExtractionOSM/src/net/osmand/NativeLibrary.java index 32b70bf96f..7ee77a9a23 100644 --- a/DataExtractionOSM/src/net/osmand/NativeLibrary.java +++ b/DataExtractionOSM/src/net/osmand/NativeLibrary.java @@ -84,6 +84,10 @@ public class NativeLibrary { return initBinaryMapFile(filePath); } + public boolean initCacheMapFile(String filePath) { + return initCacheMapFiles(filePath); + } + public boolean closeMapFile(String filePath) { return closeBinaryMapFile(filePath); } @@ -110,6 +114,8 @@ public class NativeLibrary { protected static native boolean initBinaryMapFile(String filePath); + protected static native boolean initCacheMapFiles(String filePath); + protected static native boolean closeBinaryMapFile(String filePath); protected static native void initRenderingRulesStorage(RenderingRulesStorage storage); diff --git a/DataExtractionOSM/src/net/osmand/binary/CachedOsmandIndexes.java b/DataExtractionOSM/src/net/osmand/binary/CachedOsmandIndexes.java index 1f643bf4dd..4d7df93adc 100644 --- a/DataExtractionOSM/src/net/osmand/binary/CachedOsmandIndexes.java +++ b/DataExtractionOSM/src/net/osmand/binary/CachedOsmandIndexes.java @@ -45,6 +45,11 @@ public class CachedOsmandIndexes { storedIndexBuilder = OsmandIndex.OsmAndStoredIndex.newBuilder(); storedIndexBuilder.setVersion(VERSION); storedIndexBuilder.setDateCreated(System.currentTimeMillis()); + if(storedIndex != null) { + for(FileIndex ex : storedIndex.getFileIndexList()) { + storedIndexBuilder.addFileIndex(ex); + } + } } FileIndex.Builder fileIndex = OsmandIndex.FileIndex.newBuilder(); diff --git a/DataExtractionOSM/src/osmand_index.proto b/DataExtractionOSM/src/osmand_index.proto index b4093bb650..3c87bbdecf 100644 --- a/DataExtractionOSM/src/osmand_index.proto +++ b/DataExtractionOSM/src/osmand_index.proto @@ -2,9 +2,10 @@ option java_package = "net.osmand.binary"; //protoc --java_out=DataExtractionOSM/src DataExtractionOSM/src/osmand_index.proto -// C++ # cd OsmAnd -// # protoc --proto_path=../DataExtractionOSM/src --cpp_out=jni/osmand/proto ../DataExtractionOSM/src/osmand_odb.proto +// C++ # cd OsmAnd-Kernel +// # protoc --proto_path=../DataExtractionOSM/src --cpp_out=osmand/src/proto ../DataExtractionOSM/src/osmand_index.proto +option optimize_for = LITE_RUNTIME; message OsmAndStoredIndex { required uint32 version = 1; diff --git a/OsmAnd/src/net/osmand/plus/ResourceManager.java b/OsmAnd/src/net/osmand/plus/ResourceManager.java index 38beebcb0b..1a98ee104d 100644 --- a/OsmAnd/src/net/osmand/plus/ResourceManager.java +++ b/OsmAnd/src/net/osmand/plus/ResourceManager.java @@ -39,6 +39,7 @@ import net.osmand.plus.AsyncLoadingThread.MapLoadRequest; import net.osmand.plus.AsyncLoadingThread.TileLoadDownloadRequest; import net.osmand.plus.AsyncLoadingThread.TransportLoadRequest; import net.osmand.plus.render.MapRenderRepositories; +import net.osmand.plus.render.NativeOsmandLibrary; import net.osmand.plus.views.OsmandMapLayer.DrawSettings; import net.osmand.render.RenderingRulesStorage; @@ -533,6 +534,11 @@ public class ResourceManager { if(indCache.exists()) { try { cachedOsmandIndexes.readFromFile(indCache, CachedOsmandIndexes.VERSION); + NativeOsmandLibrary nativeLib = context.getSettings().NATIVE_RENDERING.get() ? NativeOsmandLibrary.getLoadedLibrary() + : null; + if(nativeLib != null) { + nativeLib.initCacheMapFile(indCache.getAbsolutePath()); + } } catch (Exception e) { log.error(e.getMessage(), e); } @@ -546,7 +552,6 @@ public class ResourceManager { BinaryMapIndexReader index = null; try { index = cachedOsmandIndexes.getReader(f); - if (index.getVersion() != IndexConstants.BINARY_MAP_VERSION) { index = null; } diff --git a/OsmAnd/src/net/osmand/plus/render/MapRenderRepositories.java b/OsmAnd/src/net/osmand/plus/render/MapRenderRepositories.java index 90c3ce74e2..304076e001 100644 --- a/OsmAnd/src/net/osmand/plus/render/MapRenderRepositories.java +++ b/OsmAnd/src/net/osmand/plus/render/MapRenderRepositories.java @@ -114,13 +114,13 @@ public class MapRenderRepositories { NativeOsmandLibrary nativeLib = prefs.NATIVE_RENDERING.get() ? NativeOsmandLibrary.getLoadedLibrary() : null; if (nativeLib != null) { if (!nativeLib.initMapFile(file.getAbsolutePath())) { - log.debug("Initializing native db " + file.getAbsolutePath() + " failed!"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ + log.error("Initializing native db " + file.getAbsolutePath() + " failed!"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ } else { nativeFiles.add(file.getAbsolutePath()); - long val = System.currentTimeMillis(); - if (log.isDebugEnabled()) { - log.debug("Initializing native db " + file.getAbsolutePath() + " " + (val - start) + "ms"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ - } +// long val = System.currentTimeMillis(); +// if (log.isDebugEnabled()) { +// log.debug("Initializing native db " + file.getAbsolutePath() + " " + (val - start) + "ms"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ +// } } } } diff --git a/Osmand-kernel/osmand/Common.mk b/Osmand-kernel/osmand/Common.mk index 7567040ef1..4e6fa75a67 100644 --- a/Osmand-kernel/osmand/Common.mk +++ b/Osmand-kernel/osmand/Common.mk @@ -21,7 +21,8 @@ LOCAL_SRC_FILES := \ src/multipolygons.cpp \ src/renderRules.cpp \ src/rendering.cpp \ - src/binaryRead.cpp + src/binaryRead.cpp \ + src/proto/osmand_index.pb.cpp ifdef OSMAND_PROFILE_NATIVE_OPERATIONS LOCAL_CFLAGS += \ diff --git a/Osmand-kernel/osmand/src/binaryRead.cpp b/Osmand-kernel/osmand/src/binaryRead.cpp index 4edbdf45f8..159f97c8a1 100644 --- a/Osmand-kernel/osmand/src/binaryRead.cpp +++ b/Osmand-kernel/osmand/src/binaryRead.cpp @@ -9,6 +9,7 @@ #include "google/protobuf/io/zero_copy_stream_impl.h" #include "google/protobuf/wire_format_lite.cc" #include "proto/osmand_odb.pb.h" +#include "proto/osmand_index.pb.h" #include "osmand_log.h" using namespace std; @@ -20,6 +21,7 @@ using google::protobuf::internal::WireFormatLite; std::map< std::string, BinaryMapFile* > openFiles; +OsmAndStoredIndex* cache = NULL; inline bool readInt(CodedInputStream* input, uint32_t* sz ){ uint8_t buf[4]; @@ -1035,21 +1037,22 @@ ResultPublisher* searchObjectsForRendering(SearchQuery* q, bool skipDuplicates, return q->publisher; } + void searchRouteRegion(CodedInputStream* input, SearchQuery* q, RoutingIndex* ind, std::vector& subregions, - std::vector& toLoad) { + std::vector& toLoad, BinaryMapFile* file) { for (std::vector::iterator subreg = subregions.begin(); subreg != subregions.end(); subreg++) { if (subreg->right >= q->left && q->right >= subreg->left && subreg->bottom >= q->top && q->bottom >= subreg->top) { if(subreg->subregions.empty()){ bool contains = subreg->right <= q->right && q->left <= subreg->left && subreg->top <= q->top - && subreg->bottom >= q->bottom; + && subreg->bottom >= q->bottom; input->Seek(subreg->filePointer); - uint32_t old = input -> PushLimit(subreg->length); + uint32_t old = input->PushLimit(subreg->length); readRouteTree(input, &(*subreg), NULL, contains? -1 : 1, false); input->PopLimit(old); } - searchRouteRegion(input, q, ind, subreg->subregions, toLoad); + searchRouteRegion(input, q, ind, subreg->subregions, toLoad, file); if(subreg->mapDataBlock != 0) { toLoad.push_back(*subreg); } @@ -1312,11 +1315,6 @@ void searchRouteRegion(SearchQuery* q, std::vector& list, Rout bool basemapExists = false; for (; i != openFiles.end() && !q->publisher->isCancelled(); i++) { BinaryMapFile* file = i->second; - lseek(file->routefd, 0, SEEK_SET); - FileInputStream input(file->routefd); - input.SetCloseOnDelete(false); - CodedInputStream cis(&input); - cis.SetTotalBytesLimit(INT_MAX, INT_MAX >> 2); for (std::vector::iterator routingIndex = file->routingIndexes.begin(); routingIndex != file->routingIndexes.end(); routingIndex++) { if (q->publisher->isCancelled()) { @@ -1325,10 +1323,44 @@ void searchRouteRegion(SearchQuery* q, std::vector& list, Rout if(rs != NULL && (rs->name != routingIndex->name || rs->filePointer != routingIndex->filePointer)){ continue; } + // check boundaries and init + if (routingIndex->decodingRules.size() == 0) { + bool contain = false; + for (std::vector::iterator subreg = routingIndex->subregions.begin(); subreg != routingIndex->subregions.end(); + subreg++) { + if (subreg->right >= q->left && q->right >= subreg->left && subreg->bottom >= q->top + && q->bottom >= subreg->top) { + contain = true; + } + } + if (contain) { + routingIndex->subregions.clear(); + osmand_log_print(LOG_INFO, "Init native index %s", routingIndex->name.c_str()); + lseek(file->routefd, 0, SEEK_SET); + FileInputStream input(file->routefd); + input.SetCloseOnDelete(false); + CodedInputStream cis(&input); + cis.SetTotalBytesLimit(INT_MAX, INT_MAX >> 2); + + cis.Seek(routingIndex->filePointer); + uint32_t old = cis.PushLimit(routingIndex->length); + readRoutingIndex(&cis, routingIndex); + cis.PopLimit(old); + } else { + continue; + } + } + // could be simplified but it will be concurrency with init block + lseek(file->routefd, 0, SEEK_SET); + FileInputStream input(file->routefd); + input.SetCloseOnDelete(false); + CodedInputStream cis(&input); + cis.SetTotalBytesLimit(INT_MAX, INT_MAX >> 2); + std::vector toLoad; - searchRouteRegion(&cis, q, &(*routingIndex), routingIndex->subregions, toLoad); + searchRouteRegion(&cis, q, &(*routingIndex), routingIndex->subregions, toLoad, file); sort(toLoad.begin(), toLoad.end(), sortRouteRegions); - ; + std::vector iteration; int cnt = 0; for (std::vector::iterator subreg = toLoad.begin(); subreg != toLoad.end(); subreg++) { @@ -1357,6 +1389,41 @@ bool closeBinaryMapFile(std::string inputName) { return false; } +bool initMapFilesFromCache(std::string inputName) { + GOOGLE_PROTOBUF_VERIFY_VERSION; +#if defined(_WIN32) + int fileDescriptor = open(inputName.c_str(), O_RDONLY | O_BINARY); +#else + int fileDescriptor = open(inputName.c_str(), O_RDONLY); +#endif + if (fileDescriptor < 0) { + osmand_log_print(LOG_ERROR, "Cache file could not be open to read : %s", inputName.c_str()); + return false; + } + FileInputStream input(fileDescriptor); + CodedInputStream cis(&input); + cis.SetTotalBytesLimit(INT_MAX, INT_MAX); + OsmAndStoredIndex* c = new OsmAndStoredIndex(); + if(c->MergeFromCodedStream(&cis)){ + osmand_log_print(LOG_INFO, "Native Cache file initialized %s", inputName.c_str()); + cache = c; + for (int i = 0; i < cache->fileindex_size(); i++) { + FileIndex fi = cache->fileindex(i); + } + return true; + } + return false; +} + +bool hasEnding (std::string const &fullString, std::string const &ending) +{ + if (fullString.length() >= ending.length()) { + return (0 == fullString.compare (fullString.length() - ending.length(), ending.length(), ending)); + } else { + return false; + } +} + BinaryMapFile* initBinaryMapFile(std::string inputName) { GOOGLE_PROTOBUF_VERIFY_VERSION; std::map::iterator iterator; @@ -1378,16 +1445,82 @@ BinaryMapFile* initBinaryMapFile(std::string inputName) { } BinaryMapFile* mapFile = new BinaryMapFile(); mapFile->fd = fileDescriptor; - mapFile->routefd = routeDescriptor; - FileInputStream input(fileDescriptor); - input.SetCloseOnDelete(false); - CodedInputStream cis(&input); - cis.SetTotalBytesLimit(INT_MAX, INT_MAX); + struct stat stat; + fstat(fileDescriptor, &stat); - if (!initMapStructure(&cis, mapFile)) { - osmand_log_print(LOG_ERROR, "File not initialised : %s", inputName.c_str()); - delete mapFile; - return NULL; + mapFile->routefd = routeDescriptor; + bool readFromCache = cache != NULL; + FileIndex* fo = NULL; + if (readFromCache) { + for (int i = 0; i < cache->fileindex_size(); i++) { + FileIndex fi = cache->fileindex(i); + if (hasEnding(inputName, fi.filename()) && fi.size() == stat.st_size) { + fo = cache->mutable_fileindex(i); + break; + } + } + } + if (fo != NULL) { + mapFile->version = fo->version(); + mapFile->dateCreated = fo->datemodified(); + for (int i = 0; i < fo->mapindex_size(); i++) { + MapIndex mi; + MapPart mp = fo->mapindex(i); + mi.filePointer = mp.offset(); + mi.length = mp.size(); + mi.name = mp.name(); + for (int j = 0; j < mp.levels_size(); j++) { + MapLevel ml = mp.levels(j); + MapRoot mr; + mr.bottom = ml.bottom(); + mr.left = ml.left(); + mr.right = ml.right(); + mr.top = ml.top(); + mr.maxZoom = ml.maxzoom(); + mr.minZoom = ml.minzoom(); + mr.filePointer = ml.offset(); + mr.length = ml.size(); + mi.levels.push_back(mr); + } + mapFile->basemap = mapFile->basemap || mi.name.find("basemap") != string::npos; + mapFile->mapIndexes.push_back(mi); + mapFile->indexes.push_back(&mapFile->mapIndexes.back()); + } + + for (int i = 0; i < fo->routingindex_size(); i++) { + RoutingIndex mi; + RoutingPart mp = fo->routingindex(i); + mi.filePointer = mp.offset(); + mi.length = mp.size(); + mi.name = mp.name(); + for (int j = 0; j < mp.subregions_size(); j++) { + RoutingSubregion ml = mp.subregions(j); + RouteSubregion mr; + mr.bottom = ml.bottom(); + mr.left = ml.left(); + mr.right = ml.right(); + mr.top = ml.top(); + mr.mapDataBlock = ml.shiftodata(); + mr.filePointer = ml.offset(); + mr.length = ml.size(); + osmand_log_print(LOG_DEBUG, "Native file init subregion %d %d %d ", mr.filePointer, mr.length, mr.mapDataBlock); + mi.subregions.push_back(mr); + } + mapFile->routingIndexes.push_back(mi); + mapFile->indexes.push_back(&mapFile->routingIndexes.back()); + } + osmand_log_print(LOG_DEBUG, "Native file initialized from cache %s", inputName.c_str()); + } else { + FileInputStream input(fileDescriptor); + input.SetCloseOnDelete(false); + CodedInputStream cis(&input); + cis.SetTotalBytesLimit(INT_MAX, INT_MAX); + + if (!initMapStructure(&cis, mapFile)) { + osmand_log_print(LOG_ERROR, "File not initialised : %s", inputName.c_str()); + delete mapFile; + return NULL; + } } mapFile->inputName = inputName; openFiles.insert(std::pair(inputName, mapFile)); diff --git a/Osmand-kernel/osmand/src/binaryRead.h b/Osmand-kernel/osmand/src/binaryRead.h index ed7811474b..94c36bd741 100644 --- a/Osmand-kernel/osmand/src/binaryRead.h +++ b/Osmand-kernel/osmand/src/binaryRead.h @@ -249,6 +249,8 @@ ResultPublisher* searchObjectsForRendering(SearchQuery* q, bool skipDuplicates, BinaryMapFile* initBinaryMapFile(std::string inputName); +bool initMapFilesFromCache(std::string inputName) ; + bool closeBinaryMapFile(std::string inputName); #endif diff --git a/Osmand-kernel/osmand/src/java_wrap.cpp b/Osmand-kernel/osmand/src/java_wrap.cpp index 03ec1e3ba6..a1e147c5e2 100644 --- a/Osmand-kernel/osmand/src/java_wrap.cpp +++ b/Osmand-kernel/osmand/src/java_wrap.cpp @@ -52,6 +52,16 @@ extern "C" JNIEXPORT void JNICALL Java_net_osmand_NativeLibrary_closeBinaryMapFi closeBinaryMapFile(inputName); } + +extern "C" JNIEXPORT jboolean JNICALL Java_net_osmand_NativeLibrary_initCacheMapFiles(JNIEnv* ienv, + jobject obj, + jobject path) { + const char* utf = ienv->GetStringUTFChars((jstring) path, NULL); + std::string inputName(utf); + ienv->ReleaseStringUTFChars((jstring) path, utf); + return initMapFilesFromCache(inputName); +} + extern "C" JNIEXPORT jboolean JNICALL Java_net_osmand_NativeLibrary_initBinaryMapFile(JNIEnv* ienv, jobject obj, jobject path) { // Verify that the version of the library that we linked against is diff --git a/Osmand-kernel/osmand/src/proto/osmand_index.pb.cpp b/Osmand-kernel/osmand/src/proto/osmand_index.pb.cpp new file mode 100644 index 0000000000..2df8e7dc30 --- /dev/null +++ b/Osmand-kernel/osmand/src/proto/osmand_index.pb.cpp @@ -0,0 +1,3536 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "osmand_index.pb.h" +#include +#include +#include +// @@protoc_insertion_point(includes) + +void protobuf_ShutdownFile_osmand_5findex_2eproto() { + delete OsmAndStoredIndex::default_instance_; + delete FileIndex::default_instance_; + delete AddressPart::default_instance_; + delete CityBlock::default_instance_; + delete PoiPart::default_instance_; + delete MapLevel::default_instance_; + delete MapPart::default_instance_; + delete RoutingSubregion::default_instance_; + delete RoutingPart::default_instance_; + delete TransportPart::default_instance_; +} + +void protobuf_AddDesc_osmand_5findex_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + OsmAndStoredIndex::default_instance_ = new OsmAndStoredIndex(); + FileIndex::default_instance_ = new FileIndex(); + AddressPart::default_instance_ = new AddressPart(); + CityBlock::default_instance_ = new CityBlock(); + PoiPart::default_instance_ = new PoiPart(); + MapLevel::default_instance_ = new MapLevel(); + MapPart::default_instance_ = new MapPart(); + RoutingSubregion::default_instance_ = new RoutingSubregion(); + RoutingPart::default_instance_ = new RoutingPart(); + TransportPart::default_instance_ = new TransportPart(); + OsmAndStoredIndex::default_instance_->InitAsDefaultInstance(); + FileIndex::default_instance_->InitAsDefaultInstance(); + AddressPart::default_instance_->InitAsDefaultInstance(); + CityBlock::default_instance_->InitAsDefaultInstance(); + PoiPart::default_instance_->InitAsDefaultInstance(); + MapLevel::default_instance_->InitAsDefaultInstance(); + MapPart::default_instance_->InitAsDefaultInstance(); + RoutingSubregion::default_instance_->InitAsDefaultInstance(); + RoutingPart::default_instance_->InitAsDefaultInstance(); + TransportPart::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_osmand_5findex_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_osmand_5findex_2eproto { + StaticDescriptorInitializer_osmand_5findex_2eproto() { + protobuf_AddDesc_osmand_5findex_2eproto(); + } +} static_descriptor_initializer_osmand_5findex_2eproto_; + + +// =================================================================== + +#ifndef _MSC_VER +const int OsmAndStoredIndex::kVersionFieldNumber; +const int OsmAndStoredIndex::kDateCreatedFieldNumber; +const int OsmAndStoredIndex::kFileIndexFieldNumber; +#endif // !_MSC_VER + +OsmAndStoredIndex::OsmAndStoredIndex() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void OsmAndStoredIndex::InitAsDefaultInstance() { +} + +OsmAndStoredIndex::OsmAndStoredIndex(const OsmAndStoredIndex& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void OsmAndStoredIndex::SharedCtor() { + _cached_size_ = 0; + version_ = 0u; + datecreated_ = GOOGLE_LONGLONG(0); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +OsmAndStoredIndex::~OsmAndStoredIndex() { + SharedDtor(); +} + +void OsmAndStoredIndex::SharedDtor() { + if (this != default_instance_) { + } +} + +void OsmAndStoredIndex::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const OsmAndStoredIndex& OsmAndStoredIndex::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_osmand_5findex_2eproto(); return *default_instance_; +} + +OsmAndStoredIndex* OsmAndStoredIndex::default_instance_ = NULL; + +OsmAndStoredIndex* OsmAndStoredIndex::New() const { + return new OsmAndStoredIndex; +} + +void OsmAndStoredIndex::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + version_ = 0u; + datecreated_ = GOOGLE_LONGLONG(0); + } + fileindex_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool OsmAndStoredIndex::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required uint32 version = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &version_))); + _set_bit(0); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(58)) goto parse_fileIndex; + break; + } + + // repeated .FileIndex fileIndex = 7; + case 7: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_fileIndex: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_fileindex())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(58)) goto parse_fileIndex; + if (input->ExpectTag(144)) goto parse_dateCreated; + break; + } + + // required int64 dateCreated = 18; + case 18: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_dateCreated: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &datecreated_))); + _set_bit(1); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } + return true; +#undef DO_ +} + +void OsmAndStoredIndex::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required uint32 version = 1; + if (_has_bit(0)) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->version(), output); + } + + // repeated .FileIndex fileIndex = 7; + for (int i = 0; i < this->fileindex_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 7, this->fileindex(i), output); + } + + // required int64 dateCreated = 18; + if (_has_bit(1)) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(18, this->datecreated(), output); + } + +} + +int OsmAndStoredIndex::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required uint32 version = 1; + if (has_version()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->version()); + } + + // required int64 dateCreated = 18; + if (has_datecreated()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->datecreated()); + } + + } + // repeated .FileIndex fileIndex = 7; + total_size += 1 * this->fileindex_size(); + for (int i = 0; i < this->fileindex_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->fileindex(i)); + } + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void OsmAndStoredIndex::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void OsmAndStoredIndex::MergeFrom(const OsmAndStoredIndex& from) { + GOOGLE_CHECK_NE(&from, this); + fileindex_.MergeFrom(from.fileindex_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from._has_bit(0)) { + set_version(from.version()); + } + if (from._has_bit(1)) { + set_datecreated(from.datecreated()); + } + } +} + +void OsmAndStoredIndex::CopyFrom(const OsmAndStoredIndex& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool OsmAndStoredIndex::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + for (int i = 0; i < fileindex_size(); i++) { + if (!this->fileindex(i).IsInitialized()) return false; + } + return true; +} + +void OsmAndStoredIndex::Swap(OsmAndStoredIndex* other) { + if (other != this) { + std::swap(version_, other->version_); + std::swap(datecreated_, other->datecreated_); + fileindex_.Swap(&other->fileindex_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string OsmAndStoredIndex::GetTypeName() const { + return "OsmAndStoredIndex"; +} + + +// =================================================================== + +const ::std::string FileIndex::_default_filename_; +#ifndef _MSC_VER +const int FileIndex::kSizeFieldNumber; +const int FileIndex::kDateModifiedFieldNumber; +const int FileIndex::kFileNameFieldNumber; +const int FileIndex::kVersionFieldNumber; +const int FileIndex::kAddressIndexFieldNumber; +const int FileIndex::kTransportIndexFieldNumber; +const int FileIndex::kPoiIndexFieldNumber; +const int FileIndex::kMapIndexFieldNumber; +const int FileIndex::kRoutingIndexFieldNumber; +#endif // !_MSC_VER + +FileIndex::FileIndex() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void FileIndex::InitAsDefaultInstance() { +} + +FileIndex::FileIndex(const FileIndex& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void FileIndex::SharedCtor() { + _cached_size_ = 0; + size_ = GOOGLE_LONGLONG(0); + datemodified_ = GOOGLE_LONGLONG(0); + filename_ = const_cast< ::std::string*>(&_default_filename_); + version_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +FileIndex::~FileIndex() { + SharedDtor(); +} + +void FileIndex::SharedDtor() { + if (filename_ != &_default_filename_) { + delete filename_; + } + if (this != default_instance_) { + } +} + +void FileIndex::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const FileIndex& FileIndex::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_osmand_5findex_2eproto(); return *default_instance_; +} + +FileIndex* FileIndex::default_instance_ = NULL; + +FileIndex* FileIndex::New() const { + return new FileIndex; +} + +void FileIndex::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + size_ = GOOGLE_LONGLONG(0); + datemodified_ = GOOGLE_LONGLONG(0); + if (_has_bit(2)) { + if (filename_ != &_default_filename_) { + filename_->clear(); + } + } + version_ = 0; + } + addressindex_.Clear(); + transportindex_.Clear(); + poiindex_.Clear(); + mapindex_.Clear(); + routingindex_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool FileIndex::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required int64 size = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &size_))); + _set_bit(0); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_dateModified; + break; + } + + // required int64 dateModified = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_dateModified: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &datemodified_))); + _set_bit(1); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_fileName; + break; + } + + // required string fileName = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_fileName: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_filename())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(32)) goto parse_version; + break; + } + + // required int32 version = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_version: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &version_))); + _set_bit(3); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(66)) goto parse_addressIndex; + break; + } + + // repeated .AddressPart addressIndex = 8; + case 8: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_addressIndex: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_addressindex())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(66)) goto parse_addressIndex; + if (input->ExpectTag(74)) goto parse_transportIndex; + break; + } + + // repeated .TransportPart transportIndex = 9; + case 9: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_transportIndex: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_transportindex())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(74)) goto parse_transportIndex; + if (input->ExpectTag(82)) goto parse_poiIndex; + break; + } + + // repeated .PoiPart poiIndex = 10; + case 10: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_poiIndex: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_poiindex())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(82)) goto parse_poiIndex; + if (input->ExpectTag(90)) goto parse_mapIndex; + break; + } + + // repeated .MapPart mapIndex = 11; + case 11: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_mapIndex: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_mapindex())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(90)) goto parse_mapIndex; + if (input->ExpectTag(98)) goto parse_routingIndex; + break; + } + + // repeated .RoutingPart routingIndex = 12; + case 12: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_routingIndex: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_routingindex())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(98)) goto parse_routingIndex; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } + return true; +#undef DO_ +} + +void FileIndex::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required int64 size = 1; + if (_has_bit(0)) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->size(), output); + } + + // required int64 dateModified = 2; + if (_has_bit(1)) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->datemodified(), output); + } + + // required string fileName = 3; + if (_has_bit(2)) { + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->filename(), output); + } + + // required int32 version = 4; + if (_has_bit(3)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->version(), output); + } + + // repeated .AddressPart addressIndex = 8; + for (int i = 0; i < this->addressindex_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 8, this->addressindex(i), output); + } + + // repeated .TransportPart transportIndex = 9; + for (int i = 0; i < this->transportindex_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 9, this->transportindex(i), output); + } + + // repeated .PoiPart poiIndex = 10; + for (int i = 0; i < this->poiindex_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 10, this->poiindex(i), output); + } + + // repeated .MapPart mapIndex = 11; + for (int i = 0; i < this->mapindex_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 11, this->mapindex(i), output); + } + + // repeated .RoutingPart routingIndex = 12; + for (int i = 0; i < this->routingindex_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 12, this->routingindex(i), output); + } + +} + +int FileIndex::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required int64 size = 1; + if (has_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->size()); + } + + // required int64 dateModified = 2; + if (has_datemodified()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->datemodified()); + } + + // required string fileName = 3; + if (has_filename()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->filename()); + } + + // required int32 version = 4; + if (has_version()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->version()); + } + + } + // repeated .AddressPart addressIndex = 8; + total_size += 1 * this->addressindex_size(); + for (int i = 0; i < this->addressindex_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->addressindex(i)); + } + + // repeated .TransportPart transportIndex = 9; + total_size += 1 * this->transportindex_size(); + for (int i = 0; i < this->transportindex_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->transportindex(i)); + } + + // repeated .PoiPart poiIndex = 10; + total_size += 1 * this->poiindex_size(); + for (int i = 0; i < this->poiindex_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->poiindex(i)); + } + + // repeated .MapPart mapIndex = 11; + total_size += 1 * this->mapindex_size(); + for (int i = 0; i < this->mapindex_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->mapindex(i)); + } + + // repeated .RoutingPart routingIndex = 12; + total_size += 1 * this->routingindex_size(); + for (int i = 0; i < this->routingindex_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->routingindex(i)); + } + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void FileIndex::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void FileIndex::MergeFrom(const FileIndex& from) { + GOOGLE_CHECK_NE(&from, this); + addressindex_.MergeFrom(from.addressindex_); + transportindex_.MergeFrom(from.transportindex_); + poiindex_.MergeFrom(from.poiindex_); + mapindex_.MergeFrom(from.mapindex_); + routingindex_.MergeFrom(from.routingindex_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from._has_bit(0)) { + set_size(from.size()); + } + if (from._has_bit(1)) { + set_datemodified(from.datemodified()); + } + if (from._has_bit(2)) { + set_filename(from.filename()); + } + if (from._has_bit(3)) { + set_version(from.version()); + } + } +} + +void FileIndex::CopyFrom(const FileIndex& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FileIndex::IsInitialized() const { + if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false; + + for (int i = 0; i < addressindex_size(); i++) { + if (!this->addressindex(i).IsInitialized()) return false; + } + for (int i = 0; i < transportindex_size(); i++) { + if (!this->transportindex(i).IsInitialized()) return false; + } + for (int i = 0; i < poiindex_size(); i++) { + if (!this->poiindex(i).IsInitialized()) return false; + } + for (int i = 0; i < mapindex_size(); i++) { + if (!this->mapindex(i).IsInitialized()) return false; + } + for (int i = 0; i < routingindex_size(); i++) { + if (!this->routingindex(i).IsInitialized()) return false; + } + return true; +} + +void FileIndex::Swap(FileIndex* other) { + if (other != this) { + std::swap(size_, other->size_); + std::swap(datemodified_, other->datemodified_); + std::swap(filename_, other->filename_); + std::swap(version_, other->version_); + addressindex_.Swap(&other->addressindex_); + transportindex_.Swap(&other->transportindex_); + poiindex_.Swap(&other->poiindex_); + mapindex_.Swap(&other->mapindex_); + routingindex_.Swap(&other->routingindex_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string FileIndex::GetTypeName() const { + return "FileIndex"; +} + + +// =================================================================== + +const ::std::string AddressPart::_default_name_; +const ::std::string AddressPart::_default_nameen_; +#ifndef _MSC_VER +const int AddressPart::kSizeFieldNumber; +const int AddressPart::kOffsetFieldNumber; +const int AddressPart::kNameFieldNumber; +const int AddressPart::kNameEnFieldNumber; +const int AddressPart::kIndexNameOffsetFieldNumber; +const int AddressPart::kCitiesFieldNumber; +#endif // !_MSC_VER + +AddressPart::AddressPart() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void AddressPart::InitAsDefaultInstance() { +} + +AddressPart::AddressPart(const AddressPart& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void AddressPart::SharedCtor() { + _cached_size_ = 0; + size_ = GOOGLE_LONGLONG(0); + offset_ = GOOGLE_LONGLONG(0); + name_ = const_cast< ::std::string*>(&_default_name_); + nameen_ = const_cast< ::std::string*>(&_default_nameen_); + indexnameoffset_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AddressPart::~AddressPart() { + SharedDtor(); +} + +void AddressPart::SharedDtor() { + if (name_ != &_default_name_) { + delete name_; + } + if (nameen_ != &_default_nameen_) { + delete nameen_; + } + if (this != default_instance_) { + } +} + +void AddressPart::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const AddressPart& AddressPart::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_osmand_5findex_2eproto(); return *default_instance_; +} + +AddressPart* AddressPart::default_instance_ = NULL; + +AddressPart* AddressPart::New() const { + return new AddressPart; +} + +void AddressPart::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + size_ = GOOGLE_LONGLONG(0); + offset_ = GOOGLE_LONGLONG(0); + if (_has_bit(2)) { + if (name_ != &_default_name_) { + name_->clear(); + } + } + if (_has_bit(3)) { + if (nameen_ != &_default_nameen_) { + nameen_->clear(); + } + } + indexnameoffset_ = 0; + } + cities_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool AddressPart::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required int64 size = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &size_))); + _set_bit(0); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_offset; + break; + } + + // required int64 offset = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_offset: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &offset_))); + _set_bit(1); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_name; + break; + } + + // optional string name = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(34)) goto parse_nameEn; + break; + } + + // optional string nameEn = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_nameEn: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_nameen())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(40)) goto parse_indexNameOffset; + break; + } + + // optional int32 indexNameOffset = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_indexNameOffset: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &indexnameoffset_))); + _set_bit(4); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(66)) goto parse_cities; + break; + } + + // repeated .CityBlock cities = 8; + case 8: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_cities: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_cities())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(66)) goto parse_cities; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } + return true; +#undef DO_ +} + +void AddressPart::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required int64 size = 1; + if (_has_bit(0)) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->size(), output); + } + + // required int64 offset = 2; + if (_has_bit(1)) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->offset(), output); + } + + // optional string name = 3; + if (_has_bit(2)) { + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->name(), output); + } + + // optional string nameEn = 4; + if (_has_bit(3)) { + ::google::protobuf::internal::WireFormatLite::WriteString( + 4, this->nameen(), output); + } + + // optional int32 indexNameOffset = 5; + if (_has_bit(4)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->indexnameoffset(), output); + } + + // repeated .CityBlock cities = 8; + for (int i = 0; i < this->cities_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 8, this->cities(i), output); + } + +} + +int AddressPart::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required int64 size = 1; + if (has_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->size()); + } + + // required int64 offset = 2; + if (has_offset()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->offset()); + } + + // optional string name = 3; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // optional string nameEn = 4; + if (has_nameen()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->nameen()); + } + + // optional int32 indexNameOffset = 5; + if (has_indexnameoffset()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->indexnameoffset()); + } + + } + // repeated .CityBlock cities = 8; + total_size += 1 * this->cities_size(); + for (int i = 0; i < this->cities_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->cities(i)); + } + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void AddressPart::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void AddressPart::MergeFrom(const AddressPart& from) { + GOOGLE_CHECK_NE(&from, this); + cities_.MergeFrom(from.cities_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from._has_bit(0)) { + set_size(from.size()); + } + if (from._has_bit(1)) { + set_offset(from.offset()); + } + if (from._has_bit(2)) { + set_name(from.name()); + } + if (from._has_bit(3)) { + set_nameen(from.nameen()); + } + if (from._has_bit(4)) { + set_indexnameoffset(from.indexnameoffset()); + } + } +} + +void AddressPart::CopyFrom(const AddressPart& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AddressPart::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + for (int i = 0; i < cities_size(); i++) { + if (!this->cities(i).IsInitialized()) return false; + } + return true; +} + +void AddressPart::Swap(AddressPart* other) { + if (other != this) { + std::swap(size_, other->size_); + std::swap(offset_, other->offset_); + std::swap(name_, other->name_); + std::swap(nameen_, other->nameen_); + std::swap(indexnameoffset_, other->indexnameoffset_); + cities_.Swap(&other->cities_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string AddressPart::GetTypeName() const { + return "AddressPart"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int CityBlock::kSizeFieldNumber; +const int CityBlock::kOffsetFieldNumber; +const int CityBlock::kTypeFieldNumber; +#endif // !_MSC_VER + +CityBlock::CityBlock() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void CityBlock::InitAsDefaultInstance() { +} + +CityBlock::CityBlock(const CityBlock& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void CityBlock::SharedCtor() { + _cached_size_ = 0; + size_ = GOOGLE_LONGLONG(0); + offset_ = GOOGLE_LONGLONG(0); + type_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CityBlock::~CityBlock() { + SharedDtor(); +} + +void CityBlock::SharedDtor() { + if (this != default_instance_) { + } +} + +void CityBlock::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const CityBlock& CityBlock::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_osmand_5findex_2eproto(); return *default_instance_; +} + +CityBlock* CityBlock::default_instance_ = NULL; + +CityBlock* CityBlock::New() const { + return new CityBlock; +} + +void CityBlock::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + size_ = GOOGLE_LONGLONG(0); + offset_ = GOOGLE_LONGLONG(0); + type_ = 0; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool CityBlock::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required int64 size = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &size_))); + _set_bit(0); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_offset; + break; + } + + // required int64 offset = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_offset: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &offset_))); + _set_bit(1); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(24)) goto parse_type; + break; + } + + // required int32 type = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_type: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &type_))); + _set_bit(2); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } + return true; +#undef DO_ +} + +void CityBlock::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required int64 size = 1; + if (_has_bit(0)) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->size(), output); + } + + // required int64 offset = 2; + if (_has_bit(1)) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->offset(), output); + } + + // required int32 type = 3; + if (_has_bit(2)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->type(), output); + } + +} + +int CityBlock::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required int64 size = 1; + if (has_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->size()); + } + + // required int64 offset = 2; + if (has_offset()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->offset()); + } + + // required int32 type = 3; + if (has_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->type()); + } + + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void CityBlock::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void CityBlock::MergeFrom(const CityBlock& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from._has_bit(0)) { + set_size(from.size()); + } + if (from._has_bit(1)) { + set_offset(from.offset()); + } + if (from._has_bit(2)) { + set_type(from.type()); + } + } +} + +void CityBlock::CopyFrom(const CityBlock& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CityBlock::IsInitialized() const { + if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false; + + return true; +} + +void CityBlock::Swap(CityBlock* other) { + if (other != this) { + std::swap(size_, other->size_); + std::swap(offset_, other->offset_); + std::swap(type_, other->type_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string CityBlock::GetTypeName() const { + return "CityBlock"; +} + + +// =================================================================== + +const ::std::string PoiPart::_default_name_; +#ifndef _MSC_VER +const int PoiPart::kSizeFieldNumber; +const int PoiPart::kOffsetFieldNumber; +const int PoiPart::kNameFieldNumber; +const int PoiPart::kLeftFieldNumber; +const int PoiPart::kRightFieldNumber; +const int PoiPart::kTopFieldNumber; +const int PoiPart::kBottomFieldNumber; +#endif // !_MSC_VER + +PoiPart::PoiPart() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void PoiPart::InitAsDefaultInstance() { +} + +PoiPart::PoiPart(const PoiPart& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void PoiPart::SharedCtor() { + _cached_size_ = 0; + size_ = GOOGLE_LONGLONG(0); + offset_ = GOOGLE_LONGLONG(0); + name_ = const_cast< ::std::string*>(&_default_name_); + left_ = 0; + right_ = 0; + top_ = 0; + bottom_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +PoiPart::~PoiPart() { + SharedDtor(); +} + +void PoiPart::SharedDtor() { + if (name_ != &_default_name_) { + delete name_; + } + if (this != default_instance_) { + } +} + +void PoiPart::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const PoiPart& PoiPart::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_osmand_5findex_2eproto(); return *default_instance_; +} + +PoiPart* PoiPart::default_instance_ = NULL; + +PoiPart* PoiPart::New() const { + return new PoiPart; +} + +void PoiPart::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + size_ = GOOGLE_LONGLONG(0); + offset_ = GOOGLE_LONGLONG(0); + if (_has_bit(2)) { + if (name_ != &_default_name_) { + name_->clear(); + } + } + left_ = 0; + right_ = 0; + top_ = 0; + bottom_ = 0; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool PoiPart::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required int64 size = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &size_))); + _set_bit(0); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_offset; + break; + } + + // required int64 offset = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_offset: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &offset_))); + _set_bit(1); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_name; + break; + } + + // optional string name = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(32)) goto parse_left; + break; + } + + // required int32 left = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_left: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &left_))); + _set_bit(3); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(40)) goto parse_right; + break; + } + + // required int32 right = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_right: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &right_))); + _set_bit(4); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(48)) goto parse_top; + break; + } + + // required int32 top = 6; + case 6: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_top: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &top_))); + _set_bit(5); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(56)) goto parse_bottom; + break; + } + + // required int32 bottom = 7; + case 7: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_bottom: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &bottom_))); + _set_bit(6); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } + return true; +#undef DO_ +} + +void PoiPart::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required int64 size = 1; + if (_has_bit(0)) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->size(), output); + } + + // required int64 offset = 2; + if (_has_bit(1)) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->offset(), output); + } + + // optional string name = 3; + if (_has_bit(2)) { + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->name(), output); + } + + // required int32 left = 4; + if (_has_bit(3)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->left(), output); + } + + // required int32 right = 5; + if (_has_bit(4)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->right(), output); + } + + // required int32 top = 6; + if (_has_bit(5)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->top(), output); + } + + // required int32 bottom = 7; + if (_has_bit(6)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->bottom(), output); + } + +} + +int PoiPart::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required int64 size = 1; + if (has_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->size()); + } + + // required int64 offset = 2; + if (has_offset()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->offset()); + } + + // optional string name = 3; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // required int32 left = 4; + if (has_left()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->left()); + } + + // required int32 right = 5; + if (has_right()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->right()); + } + + // required int32 top = 6; + if (has_top()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->top()); + } + + // required int32 bottom = 7; + if (has_bottom()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->bottom()); + } + + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void PoiPart::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void PoiPart::MergeFrom(const PoiPart& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from._has_bit(0)) { + set_size(from.size()); + } + if (from._has_bit(1)) { + set_offset(from.offset()); + } + if (from._has_bit(2)) { + set_name(from.name()); + } + if (from._has_bit(3)) { + set_left(from.left()); + } + if (from._has_bit(4)) { + set_right(from.right()); + } + if (from._has_bit(5)) { + set_top(from.top()); + } + if (from._has_bit(6)) { + set_bottom(from.bottom()); + } + } +} + +void PoiPart::CopyFrom(const PoiPart& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PoiPart::IsInitialized() const { + if ((_has_bits_[0] & 0x0000007b) != 0x0000007b) return false; + + return true; +} + +void PoiPart::Swap(PoiPart* other) { + if (other != this) { + std::swap(size_, other->size_); + std::swap(offset_, other->offset_); + std::swap(name_, other->name_); + std::swap(left_, other->left_); + std::swap(right_, other->right_); + std::swap(top_, other->top_); + std::swap(bottom_, other->bottom_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string PoiPart::GetTypeName() const { + return "PoiPart"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int MapLevel::kSizeFieldNumber; +const int MapLevel::kOffsetFieldNumber; +const int MapLevel::kLeftFieldNumber; +const int MapLevel::kRightFieldNumber; +const int MapLevel::kTopFieldNumber; +const int MapLevel::kBottomFieldNumber; +const int MapLevel::kMinzoomFieldNumber; +const int MapLevel::kMaxzoomFieldNumber; +#endif // !_MSC_VER + +MapLevel::MapLevel() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void MapLevel::InitAsDefaultInstance() { +} + +MapLevel::MapLevel(const MapLevel& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void MapLevel::SharedCtor() { + _cached_size_ = 0; + size_ = GOOGLE_LONGLONG(0); + offset_ = GOOGLE_LONGLONG(0); + left_ = 0; + right_ = 0; + top_ = 0; + bottom_ = 0; + minzoom_ = 0; + maxzoom_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +MapLevel::~MapLevel() { + SharedDtor(); +} + +void MapLevel::SharedDtor() { + if (this != default_instance_) { + } +} + +void MapLevel::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const MapLevel& MapLevel::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_osmand_5findex_2eproto(); return *default_instance_; +} + +MapLevel* MapLevel::default_instance_ = NULL; + +MapLevel* MapLevel::New() const { + return new MapLevel; +} + +void MapLevel::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + size_ = GOOGLE_LONGLONG(0); + offset_ = GOOGLE_LONGLONG(0); + left_ = 0; + right_ = 0; + top_ = 0; + bottom_ = 0; + minzoom_ = 0; + maxzoom_ = 0; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool MapLevel::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required int64 size = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &size_))); + _set_bit(0); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_offset; + break; + } + + // required int64 offset = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_offset: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &offset_))); + _set_bit(1); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(32)) goto parse_left; + break; + } + + // required int32 left = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_left: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &left_))); + _set_bit(2); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(40)) goto parse_right; + break; + } + + // required int32 right = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_right: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &right_))); + _set_bit(3); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(48)) goto parse_top; + break; + } + + // required int32 top = 6; + case 6: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_top: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &top_))); + _set_bit(4); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(56)) goto parse_bottom; + break; + } + + // required int32 bottom = 7; + case 7: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_bottom: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &bottom_))); + _set_bit(5); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(64)) goto parse_minzoom; + break; + } + + // optional int32 minzoom = 8; + case 8: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_minzoom: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &minzoom_))); + _set_bit(6); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(72)) goto parse_maxzoom; + break; + } + + // optional int32 maxzoom = 9; + case 9: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_maxzoom: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &maxzoom_))); + _set_bit(7); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } + return true; +#undef DO_ +} + +void MapLevel::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required int64 size = 1; + if (_has_bit(0)) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->size(), output); + } + + // required int64 offset = 2; + if (_has_bit(1)) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->offset(), output); + } + + // required int32 left = 4; + if (_has_bit(2)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->left(), output); + } + + // required int32 right = 5; + if (_has_bit(3)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->right(), output); + } + + // required int32 top = 6; + if (_has_bit(4)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->top(), output); + } + + // required int32 bottom = 7; + if (_has_bit(5)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->bottom(), output); + } + + // optional int32 minzoom = 8; + if (_has_bit(6)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(8, this->minzoom(), output); + } + + // optional int32 maxzoom = 9; + if (_has_bit(7)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(9, this->maxzoom(), output); + } + +} + +int MapLevel::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required int64 size = 1; + if (has_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->size()); + } + + // required int64 offset = 2; + if (has_offset()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->offset()); + } + + // required int32 left = 4; + if (has_left()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->left()); + } + + // required int32 right = 5; + if (has_right()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->right()); + } + + // required int32 top = 6; + if (has_top()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->top()); + } + + // required int32 bottom = 7; + if (has_bottom()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->bottom()); + } + + // optional int32 minzoom = 8; + if (has_minzoom()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->minzoom()); + } + + // optional int32 maxzoom = 9; + if (has_maxzoom()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->maxzoom()); + } + + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void MapLevel::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void MapLevel::MergeFrom(const MapLevel& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from._has_bit(0)) { + set_size(from.size()); + } + if (from._has_bit(1)) { + set_offset(from.offset()); + } + if (from._has_bit(2)) { + set_left(from.left()); + } + if (from._has_bit(3)) { + set_right(from.right()); + } + if (from._has_bit(4)) { + set_top(from.top()); + } + if (from._has_bit(5)) { + set_bottom(from.bottom()); + } + if (from._has_bit(6)) { + set_minzoom(from.minzoom()); + } + if (from._has_bit(7)) { + set_maxzoom(from.maxzoom()); + } + } +} + +void MapLevel::CopyFrom(const MapLevel& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MapLevel::IsInitialized() const { + if ((_has_bits_[0] & 0x0000003f) != 0x0000003f) return false; + + return true; +} + +void MapLevel::Swap(MapLevel* other) { + if (other != this) { + std::swap(size_, other->size_); + std::swap(offset_, other->offset_); + std::swap(left_, other->left_); + std::swap(right_, other->right_); + std::swap(top_, other->top_); + std::swap(bottom_, other->bottom_); + std::swap(minzoom_, other->minzoom_); + std::swap(maxzoom_, other->maxzoom_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string MapLevel::GetTypeName() const { + return "MapLevel"; +} + + +// =================================================================== + +const ::std::string MapPart::_default_name_; +#ifndef _MSC_VER +const int MapPart::kSizeFieldNumber; +const int MapPart::kOffsetFieldNumber; +const int MapPart::kNameFieldNumber; +const int MapPart::kLevelsFieldNumber; +#endif // !_MSC_VER + +MapPart::MapPart() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void MapPart::InitAsDefaultInstance() { +} + +MapPart::MapPart(const MapPart& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void MapPart::SharedCtor() { + _cached_size_ = 0; + size_ = GOOGLE_LONGLONG(0); + offset_ = GOOGLE_LONGLONG(0); + name_ = const_cast< ::std::string*>(&_default_name_); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +MapPart::~MapPart() { + SharedDtor(); +} + +void MapPart::SharedDtor() { + if (name_ != &_default_name_) { + delete name_; + } + if (this != default_instance_) { + } +} + +void MapPart::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const MapPart& MapPart::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_osmand_5findex_2eproto(); return *default_instance_; +} + +MapPart* MapPart::default_instance_ = NULL; + +MapPart* MapPart::New() const { + return new MapPart; +} + +void MapPart::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + size_ = GOOGLE_LONGLONG(0); + offset_ = GOOGLE_LONGLONG(0); + if (_has_bit(2)) { + if (name_ != &_default_name_) { + name_->clear(); + } + } + } + levels_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool MapPart::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required int64 size = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &size_))); + _set_bit(0); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_offset; + break; + } + + // required int64 offset = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_offset: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &offset_))); + _set_bit(1); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_name; + break; + } + + // optional string name = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(42)) goto parse_levels; + break; + } + + // repeated .MapLevel levels = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_levels: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_levels())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(42)) goto parse_levels; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } + return true; +#undef DO_ +} + +void MapPart::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required int64 size = 1; + if (_has_bit(0)) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->size(), output); + } + + // required int64 offset = 2; + if (_has_bit(1)) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->offset(), output); + } + + // optional string name = 3; + if (_has_bit(2)) { + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->name(), output); + } + + // repeated .MapLevel levels = 5; + for (int i = 0; i < this->levels_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 5, this->levels(i), output); + } + +} + +int MapPart::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required int64 size = 1; + if (has_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->size()); + } + + // required int64 offset = 2; + if (has_offset()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->offset()); + } + + // optional string name = 3; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + } + // repeated .MapLevel levels = 5; + total_size += 1 * this->levels_size(); + for (int i = 0; i < this->levels_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->levels(i)); + } + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void MapPart::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void MapPart::MergeFrom(const MapPart& from) { + GOOGLE_CHECK_NE(&from, this); + levels_.MergeFrom(from.levels_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from._has_bit(0)) { + set_size(from.size()); + } + if (from._has_bit(1)) { + set_offset(from.offset()); + } + if (from._has_bit(2)) { + set_name(from.name()); + } + } +} + +void MapPart::CopyFrom(const MapPart& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MapPart::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + for (int i = 0; i < levels_size(); i++) { + if (!this->levels(i).IsInitialized()) return false; + } + return true; +} + +void MapPart::Swap(MapPart* other) { + if (other != this) { + std::swap(size_, other->size_); + std::swap(offset_, other->offset_); + std::swap(name_, other->name_); + levels_.Swap(&other->levels_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string MapPart::GetTypeName() const { + return "MapPart"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int RoutingSubregion::kSizeFieldNumber; +const int RoutingSubregion::kOffsetFieldNumber; +const int RoutingSubregion::kLeftFieldNumber; +const int RoutingSubregion::kRightFieldNumber; +const int RoutingSubregion::kTopFieldNumber; +const int RoutingSubregion::kBottomFieldNumber; +const int RoutingSubregion::kShifToDataFieldNumber; +#endif // !_MSC_VER + +RoutingSubregion::RoutingSubregion() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void RoutingSubregion::InitAsDefaultInstance() { +} + +RoutingSubregion::RoutingSubregion(const RoutingSubregion& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void RoutingSubregion::SharedCtor() { + _cached_size_ = 0; + size_ = GOOGLE_LONGLONG(0); + offset_ = GOOGLE_LONGLONG(0); + left_ = 0; + right_ = 0; + top_ = 0; + bottom_ = 0; + shiftodata_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +RoutingSubregion::~RoutingSubregion() { + SharedDtor(); +} + +void RoutingSubregion::SharedDtor() { + if (this != default_instance_) { + } +} + +void RoutingSubregion::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const RoutingSubregion& RoutingSubregion::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_osmand_5findex_2eproto(); return *default_instance_; +} + +RoutingSubregion* RoutingSubregion::default_instance_ = NULL; + +RoutingSubregion* RoutingSubregion::New() const { + return new RoutingSubregion; +} + +void RoutingSubregion::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + size_ = GOOGLE_LONGLONG(0); + offset_ = GOOGLE_LONGLONG(0); + left_ = 0; + right_ = 0; + top_ = 0; + bottom_ = 0; + shiftodata_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool RoutingSubregion::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required int64 size = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &size_))); + _set_bit(0); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_offset; + break; + } + + // required int64 offset = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_offset: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &offset_))); + _set_bit(1); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(32)) goto parse_left; + break; + } + + // required int32 left = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_left: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &left_))); + _set_bit(2); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(40)) goto parse_right; + break; + } + + // required int32 right = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_right: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &right_))); + _set_bit(3); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(48)) goto parse_top; + break; + } + + // required int32 top = 6; + case 6: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_top: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &top_))); + _set_bit(4); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(56)) goto parse_bottom; + break; + } + + // required int32 bottom = 7; + case 7: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_bottom: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &bottom_))); + _set_bit(5); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(64)) goto parse_shifToData; + break; + } + + // required uint32 shifToData = 8; + case 8: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_shifToData: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &shiftodata_))); + _set_bit(6); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } + return true; +#undef DO_ +} + +void RoutingSubregion::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required int64 size = 1; + if (_has_bit(0)) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->size(), output); + } + + // required int64 offset = 2; + if (_has_bit(1)) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->offset(), output); + } + + // required int32 left = 4; + if (_has_bit(2)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->left(), output); + } + + // required int32 right = 5; + if (_has_bit(3)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->right(), output); + } + + // required int32 top = 6; + if (_has_bit(4)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->top(), output); + } + + // required int32 bottom = 7; + if (_has_bit(5)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->bottom(), output); + } + + // required uint32 shifToData = 8; + if (_has_bit(6)) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(8, this->shiftodata(), output); + } + +} + +int RoutingSubregion::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required int64 size = 1; + if (has_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->size()); + } + + // required int64 offset = 2; + if (has_offset()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->offset()); + } + + // required int32 left = 4; + if (has_left()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->left()); + } + + // required int32 right = 5; + if (has_right()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->right()); + } + + // required int32 top = 6; + if (has_top()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->top()); + } + + // required int32 bottom = 7; + if (has_bottom()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->bottom()); + } + + // required uint32 shifToData = 8; + if (has_shiftodata()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->shiftodata()); + } + + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void RoutingSubregion::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void RoutingSubregion::MergeFrom(const RoutingSubregion& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from._has_bit(0)) { + set_size(from.size()); + } + if (from._has_bit(1)) { + set_offset(from.offset()); + } + if (from._has_bit(2)) { + set_left(from.left()); + } + if (from._has_bit(3)) { + set_right(from.right()); + } + if (from._has_bit(4)) { + set_top(from.top()); + } + if (from._has_bit(5)) { + set_bottom(from.bottom()); + } + if (from._has_bit(6)) { + set_shiftodata(from.shiftodata()); + } + } +} + +void RoutingSubregion::CopyFrom(const RoutingSubregion& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RoutingSubregion::IsInitialized() const { + if ((_has_bits_[0] & 0x0000007f) != 0x0000007f) return false; + + return true; +} + +void RoutingSubregion::Swap(RoutingSubregion* other) { + if (other != this) { + std::swap(size_, other->size_); + std::swap(offset_, other->offset_); + std::swap(left_, other->left_); + std::swap(right_, other->right_); + std::swap(top_, other->top_); + std::swap(bottom_, other->bottom_); + std::swap(shiftodata_, other->shiftodata_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string RoutingSubregion::GetTypeName() const { + return "RoutingSubregion"; +} + + +// =================================================================== + +const ::std::string RoutingPart::_default_name_; +#ifndef _MSC_VER +const int RoutingPart::kSizeFieldNumber; +const int RoutingPart::kOffsetFieldNumber; +const int RoutingPart::kNameFieldNumber; +const int RoutingPart::kSubregionsFieldNumber; +#endif // !_MSC_VER + +RoutingPart::RoutingPart() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void RoutingPart::InitAsDefaultInstance() { +} + +RoutingPart::RoutingPart(const RoutingPart& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void RoutingPart::SharedCtor() { + _cached_size_ = 0; + size_ = GOOGLE_LONGLONG(0); + offset_ = GOOGLE_LONGLONG(0); + name_ = const_cast< ::std::string*>(&_default_name_); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +RoutingPart::~RoutingPart() { + SharedDtor(); +} + +void RoutingPart::SharedDtor() { + if (name_ != &_default_name_) { + delete name_; + } + if (this != default_instance_) { + } +} + +void RoutingPart::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const RoutingPart& RoutingPart::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_osmand_5findex_2eproto(); return *default_instance_; +} + +RoutingPart* RoutingPart::default_instance_ = NULL; + +RoutingPart* RoutingPart::New() const { + return new RoutingPart; +} + +void RoutingPart::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + size_ = GOOGLE_LONGLONG(0); + offset_ = GOOGLE_LONGLONG(0); + if (_has_bit(2)) { + if (name_ != &_default_name_) { + name_->clear(); + } + } + } + subregions_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool RoutingPart::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required int64 size = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &size_))); + _set_bit(0); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_offset; + break; + } + + // required int64 offset = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_offset: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &offset_))); + _set_bit(1); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_name; + break; + } + + // optional string name = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(42)) goto parse_subregions; + break; + } + + // repeated .RoutingSubregion subregions = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_subregions: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_subregions())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(42)) goto parse_subregions; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } + return true; +#undef DO_ +} + +void RoutingPart::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required int64 size = 1; + if (_has_bit(0)) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->size(), output); + } + + // required int64 offset = 2; + if (_has_bit(1)) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->offset(), output); + } + + // optional string name = 3; + if (_has_bit(2)) { + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->name(), output); + } + + // repeated .RoutingSubregion subregions = 5; + for (int i = 0; i < this->subregions_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 5, this->subregions(i), output); + } + +} + +int RoutingPart::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required int64 size = 1; + if (has_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->size()); + } + + // required int64 offset = 2; + if (has_offset()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->offset()); + } + + // optional string name = 3; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + } + // repeated .RoutingSubregion subregions = 5; + total_size += 1 * this->subregions_size(); + for (int i = 0; i < this->subregions_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->subregions(i)); + } + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void RoutingPart::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void RoutingPart::MergeFrom(const RoutingPart& from) { + GOOGLE_CHECK_NE(&from, this); + subregions_.MergeFrom(from.subregions_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from._has_bit(0)) { + set_size(from.size()); + } + if (from._has_bit(1)) { + set_offset(from.offset()); + } + if (from._has_bit(2)) { + set_name(from.name()); + } + } +} + +void RoutingPart::CopyFrom(const RoutingPart& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RoutingPart::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + for (int i = 0; i < subregions_size(); i++) { + if (!this->subregions(i).IsInitialized()) return false; + } + return true; +} + +void RoutingPart::Swap(RoutingPart* other) { + if (other != this) { + std::swap(size_, other->size_); + std::swap(offset_, other->offset_); + std::swap(name_, other->name_); + subregions_.Swap(&other->subregions_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string RoutingPart::GetTypeName() const { + return "RoutingPart"; +} + + +// =================================================================== + +const ::std::string TransportPart::_default_name_; +#ifndef _MSC_VER +const int TransportPart::kSizeFieldNumber; +const int TransportPart::kOffsetFieldNumber; +const int TransportPart::kNameFieldNumber; +const int TransportPart::kLeftFieldNumber; +const int TransportPart::kRightFieldNumber; +const int TransportPart::kTopFieldNumber; +const int TransportPart::kBottomFieldNumber; +const int TransportPart::kStringTableOffsetFieldNumber; +const int TransportPart::kStringTableLengthFieldNumber; +const int TransportPart::kStopsTableOffsetFieldNumber; +const int TransportPart::kStopsTableLengthFieldNumber; +#endif // !_MSC_VER + +TransportPart::TransportPart() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void TransportPart::InitAsDefaultInstance() { +} + +TransportPart::TransportPart(const TransportPart& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void TransportPart::SharedCtor() { + _cached_size_ = 0; + size_ = GOOGLE_LONGLONG(0); + offset_ = GOOGLE_LONGLONG(0); + name_ = const_cast< ::std::string*>(&_default_name_); + left_ = 0; + right_ = 0; + top_ = 0; + bottom_ = 0; + stringtableoffset_ = 0u; + stringtablelength_ = 0u; + stopstableoffset_ = 0u; + stopstablelength_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +TransportPart::~TransportPart() { + SharedDtor(); +} + +void TransportPart::SharedDtor() { + if (name_ != &_default_name_) { + delete name_; + } + if (this != default_instance_) { + } +} + +void TransportPart::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const TransportPart& TransportPart::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_osmand_5findex_2eproto(); return *default_instance_; +} + +TransportPart* TransportPart::default_instance_ = NULL; + +TransportPart* TransportPart::New() const { + return new TransportPart; +} + +void TransportPart::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + size_ = GOOGLE_LONGLONG(0); + offset_ = GOOGLE_LONGLONG(0); + if (_has_bit(2)) { + if (name_ != &_default_name_) { + name_->clear(); + } + } + left_ = 0; + right_ = 0; + top_ = 0; + bottom_ = 0; + stringtableoffset_ = 0u; + } + if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + stringtablelength_ = 0u; + stopstableoffset_ = 0u; + stopstablelength_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool TransportPart::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required int64 size = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &size_))); + _set_bit(0); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_offset; + break; + } + + // required int64 offset = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_offset: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &offset_))); + _set_bit(1); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_name; + break; + } + + // optional string name = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_name: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(32)) goto parse_left; + break; + } + + // optional int32 left = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_left: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &left_))); + _set_bit(3); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(40)) goto parse_right; + break; + } + + // optional int32 right = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_right: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &right_))); + _set_bit(4); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(48)) goto parse_top; + break; + } + + // optional int32 top = 6; + case 6: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_top: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &top_))); + _set_bit(5); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(56)) goto parse_bottom; + break; + } + + // optional int32 bottom = 7; + case 7: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_bottom: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &bottom_))); + _set_bit(6); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(64)) goto parse_stringTableOffset; + break; + } + + // optional uint32 stringTableOffset = 8; + case 8: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_stringTableOffset: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &stringtableoffset_))); + _set_bit(7); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(72)) goto parse_stringTableLength; + break; + } + + // optional uint32 stringTableLength = 9; + case 9: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_stringTableLength: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &stringtablelength_))); + _set_bit(8); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(80)) goto parse_stopsTableOffset; + break; + } + + // optional uint32 stopsTableOffset = 10; + case 10: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_stopsTableOffset: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &stopstableoffset_))); + _set_bit(9); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(88)) goto parse_stopsTableLength; + break; + } + + // optional uint32 stopsTableLength = 11; + case 11: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_stopsTableLength: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &stopstablelength_))); + _set_bit(10); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } + return true; +#undef DO_ +} + +void TransportPart::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required int64 size = 1; + if (_has_bit(0)) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->size(), output); + } + + // required int64 offset = 2; + if (_has_bit(1)) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->offset(), output); + } + + // optional string name = 3; + if (_has_bit(2)) { + ::google::protobuf::internal::WireFormatLite::WriteString( + 3, this->name(), output); + } + + // optional int32 left = 4; + if (_has_bit(3)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->left(), output); + } + + // optional int32 right = 5; + if (_has_bit(4)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->right(), output); + } + + // optional int32 top = 6; + if (_has_bit(5)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->top(), output); + } + + // optional int32 bottom = 7; + if (_has_bit(6)) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->bottom(), output); + } + + // optional uint32 stringTableOffset = 8; + if (_has_bit(7)) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(8, this->stringtableoffset(), output); + } + + // optional uint32 stringTableLength = 9; + if (_has_bit(8)) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(9, this->stringtablelength(), output); + } + + // optional uint32 stopsTableOffset = 10; + if (_has_bit(9)) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(10, this->stopstableoffset(), output); + } + + // optional uint32 stopsTableLength = 11; + if (_has_bit(10)) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(11, this->stopstablelength(), output); + } + +} + +int TransportPart::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required int64 size = 1; + if (has_size()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->size()); + } + + // required int64 offset = 2; + if (has_offset()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->offset()); + } + + // optional string name = 3; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // optional int32 left = 4; + if (has_left()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->left()); + } + + // optional int32 right = 5; + if (has_right()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->right()); + } + + // optional int32 top = 6; + if (has_top()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->top()); + } + + // optional int32 bottom = 7; + if (has_bottom()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->bottom()); + } + + // optional uint32 stringTableOffset = 8; + if (has_stringtableoffset()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->stringtableoffset()); + } + + } + if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + // optional uint32 stringTableLength = 9; + if (has_stringtablelength()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->stringtablelength()); + } + + // optional uint32 stopsTableOffset = 10; + if (has_stopstableoffset()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->stopstableoffset()); + } + + // optional uint32 stopsTableLength = 11; + if (has_stopstablelength()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->stopstablelength()); + } + + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void TransportPart::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void TransportPart::MergeFrom(const TransportPart& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from._has_bit(0)) { + set_size(from.size()); + } + if (from._has_bit(1)) { + set_offset(from.offset()); + } + if (from._has_bit(2)) { + set_name(from.name()); + } + if (from._has_bit(3)) { + set_left(from.left()); + } + if (from._has_bit(4)) { + set_right(from.right()); + } + if (from._has_bit(5)) { + set_top(from.top()); + } + if (from._has_bit(6)) { + set_bottom(from.bottom()); + } + if (from._has_bit(7)) { + set_stringtableoffset(from.stringtableoffset()); + } + } + if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (from._has_bit(8)) { + set_stringtablelength(from.stringtablelength()); + } + if (from._has_bit(9)) { + set_stopstableoffset(from.stopstableoffset()); + } + if (from._has_bit(10)) { + set_stopstablelength(from.stopstablelength()); + } + } +} + +void TransportPart::CopyFrom(const TransportPart& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool TransportPart::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void TransportPart::Swap(TransportPart* other) { + if (other != this) { + std::swap(size_, other->size_); + std::swap(offset_, other->offset_); + std::swap(name_, other->name_); + std::swap(left_, other->left_); + std::swap(right_, other->right_); + std::swap(top_, other->top_); + std::swap(bottom_, other->bottom_); + std::swap(stringtableoffset_, other->stringtableoffset_); + std::swap(stringtablelength_, other->stringtablelength_); + std::swap(stopstableoffset_, other->stopstableoffset_); + std::swap(stopstablelength_, other->stopstablelength_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string TransportPart::GetTypeName() const { + return "TransportPart"; +} + + +// @@protoc_insertion_point(namespace_scope) + +// @@protoc_insertion_point(global_scope) diff --git a/Osmand-kernel/osmand/src/proto/osmand_index.pb.h b/Osmand-kernel/osmand/src/proto/osmand_index.pb.h new file mode 100644 index 0000000000..6669d1bc73 --- /dev/null +++ b/Osmand-kernel/osmand/src/proto/osmand_index.pb.h @@ -0,0 +1,2605 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: osmand_index.proto + +#ifndef PROTOBUF_osmand_5findex_2eproto__INCLUDED +#define PROTOBUF_osmand_5findex_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2003000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 2003000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +// @@protoc_insertion_point(includes) + +// Internal implementation detail -- do not call these. +void protobuf_AddDesc_osmand_5findex_2eproto(); +void protobuf_AssignDesc_osmand_5findex_2eproto(); +void protobuf_ShutdownFile_osmand_5findex_2eproto(); + +class OsmAndStoredIndex; +class FileIndex; +class AddressPart; +class CityBlock; +class PoiPart; +class MapLevel; +class MapPart; +class RoutingSubregion; +class RoutingPart; +class TransportPart; + +// =================================================================== + +class OsmAndStoredIndex : public ::google::protobuf::MessageLite { + public: + OsmAndStoredIndex(); + virtual ~OsmAndStoredIndex(); + + OsmAndStoredIndex(const OsmAndStoredIndex& from); + + inline OsmAndStoredIndex& operator=(const OsmAndStoredIndex& from) { + CopyFrom(from); + return *this; + } + + static const OsmAndStoredIndex& default_instance(); + + void Swap(OsmAndStoredIndex* other); + + // implements Message ---------------------------------------------- + + OsmAndStoredIndex* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const OsmAndStoredIndex& from); + void MergeFrom(const OsmAndStoredIndex& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required uint32 version = 1; + inline bool has_version() const; + inline void clear_version(); + static const int kVersionFieldNumber = 1; + inline ::google::protobuf::uint32 version() const; + inline void set_version(::google::protobuf::uint32 value); + + // required int64 dateCreated = 18; + inline bool has_datecreated() const; + inline void clear_datecreated(); + static const int kDateCreatedFieldNumber = 18; + inline ::google::protobuf::int64 datecreated() const; + inline void set_datecreated(::google::protobuf::int64 value); + + // repeated .FileIndex fileIndex = 7; + inline int fileindex_size() const; + inline void clear_fileindex(); + static const int kFileIndexFieldNumber = 7; + inline const ::FileIndex& fileindex(int index) const; + inline ::FileIndex* mutable_fileindex(int index); + inline ::FileIndex* add_fileindex(); + inline const ::google::protobuf::RepeatedPtrField< ::FileIndex >& + fileindex() const; + inline ::google::protobuf::RepeatedPtrField< ::FileIndex >* + mutable_fileindex(); + + // @@protoc_insertion_point(class_scope:OsmAndStoredIndex) + private: + mutable int _cached_size_; + + ::google::protobuf::uint32 version_; + ::google::protobuf::int64 datecreated_; + ::google::protobuf::RepeatedPtrField< ::FileIndex > fileindex_; + friend void protobuf_AddDesc_osmand_5findex_2eproto(); + friend void protobuf_AssignDesc_osmand_5findex_2eproto(); + friend void protobuf_ShutdownFile_osmand_5findex_2eproto(); + + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? + inline bool _has_bit(int index) const { + return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; + } + inline void _set_bit(int index) { + _has_bits_[index / 32] |= (1u << (index % 32)); + } + inline void _clear_bit(int index) { + _has_bits_[index / 32] &= ~(1u << (index % 32)); + } + + void InitAsDefaultInstance(); + static OsmAndStoredIndex* default_instance_; +}; +// ------------------------------------------------------------------- + +class FileIndex : public ::google::protobuf::MessageLite { + public: + FileIndex(); + virtual ~FileIndex(); + + FileIndex(const FileIndex& from); + + inline FileIndex& operator=(const FileIndex& from) { + CopyFrom(from); + return *this; + } + + static const FileIndex& default_instance(); + + void Swap(FileIndex* other); + + // implements Message ---------------------------------------------- + + FileIndex* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const FileIndex& from); + void MergeFrom(const FileIndex& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required int64 size = 1; + inline bool has_size() const; + inline void clear_size(); + static const int kSizeFieldNumber = 1; + inline ::google::protobuf::int64 size() const; + inline void set_size(::google::protobuf::int64 value); + + // required int64 dateModified = 2; + inline bool has_datemodified() const; + inline void clear_datemodified(); + static const int kDateModifiedFieldNumber = 2; + inline ::google::protobuf::int64 datemodified() const; + inline void set_datemodified(::google::protobuf::int64 value); + + // required string fileName = 3; + inline bool has_filename() const; + inline void clear_filename(); + static const int kFileNameFieldNumber = 3; + inline const ::std::string& filename() const; + inline void set_filename(const ::std::string& value); + inline void set_filename(const char* value); + inline void set_filename(const char* value, size_t size); + inline ::std::string* mutable_filename(); + + // required int32 version = 4; + inline bool has_version() const; + inline void clear_version(); + static const int kVersionFieldNumber = 4; + inline ::google::protobuf::int32 version() const; + inline void set_version(::google::protobuf::int32 value); + + // repeated .AddressPart addressIndex = 8; + inline int addressindex_size() const; + inline void clear_addressindex(); + static const int kAddressIndexFieldNumber = 8; + inline const ::AddressPart& addressindex(int index) const; + inline ::AddressPart* mutable_addressindex(int index); + inline ::AddressPart* add_addressindex(); + inline const ::google::protobuf::RepeatedPtrField< ::AddressPart >& + addressindex() const; + inline ::google::protobuf::RepeatedPtrField< ::AddressPart >* + mutable_addressindex(); + + // repeated .TransportPart transportIndex = 9; + inline int transportindex_size() const; + inline void clear_transportindex(); + static const int kTransportIndexFieldNumber = 9; + inline const ::TransportPart& transportindex(int index) const; + inline ::TransportPart* mutable_transportindex(int index); + inline ::TransportPart* add_transportindex(); + inline const ::google::protobuf::RepeatedPtrField< ::TransportPart >& + transportindex() const; + inline ::google::protobuf::RepeatedPtrField< ::TransportPart >* + mutable_transportindex(); + + // repeated .PoiPart poiIndex = 10; + inline int poiindex_size() const; + inline void clear_poiindex(); + static const int kPoiIndexFieldNumber = 10; + inline const ::PoiPart& poiindex(int index) const; + inline ::PoiPart* mutable_poiindex(int index); + inline ::PoiPart* add_poiindex(); + inline const ::google::protobuf::RepeatedPtrField< ::PoiPart >& + poiindex() const; + inline ::google::protobuf::RepeatedPtrField< ::PoiPart >* + mutable_poiindex(); + + // repeated .MapPart mapIndex = 11; + inline int mapindex_size() const; + inline void clear_mapindex(); + static const int kMapIndexFieldNumber = 11; + inline const ::MapPart& mapindex(int index) const; + inline ::MapPart* mutable_mapindex(int index); + inline ::MapPart* add_mapindex(); + inline const ::google::protobuf::RepeatedPtrField< ::MapPart >& + mapindex() const; + inline ::google::protobuf::RepeatedPtrField< ::MapPart >* + mutable_mapindex(); + + // repeated .RoutingPart routingIndex = 12; + inline int routingindex_size() const; + inline void clear_routingindex(); + static const int kRoutingIndexFieldNumber = 12; + inline const ::RoutingPart& routingindex(int index) const; + inline ::RoutingPart* mutable_routingindex(int index); + inline ::RoutingPart* add_routingindex(); + inline const ::google::protobuf::RepeatedPtrField< ::RoutingPart >& + routingindex() const; + inline ::google::protobuf::RepeatedPtrField< ::RoutingPart >* + mutable_routingindex(); + + // @@protoc_insertion_point(class_scope:FileIndex) + private: + mutable int _cached_size_; + + ::google::protobuf::int64 size_; + ::google::protobuf::int64 datemodified_; + ::std::string* filename_; + static const ::std::string _default_filename_; + ::google::protobuf::int32 version_; + ::google::protobuf::RepeatedPtrField< ::AddressPart > addressindex_; + ::google::protobuf::RepeatedPtrField< ::TransportPart > transportindex_; + ::google::protobuf::RepeatedPtrField< ::PoiPart > poiindex_; + ::google::protobuf::RepeatedPtrField< ::MapPart > mapindex_; + ::google::protobuf::RepeatedPtrField< ::RoutingPart > routingindex_; + friend void protobuf_AddDesc_osmand_5findex_2eproto(); + friend void protobuf_AssignDesc_osmand_5findex_2eproto(); + friend void protobuf_ShutdownFile_osmand_5findex_2eproto(); + + ::google::protobuf::uint32 _has_bits_[(9 + 31) / 32]; + + // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? + inline bool _has_bit(int index) const { + return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; + } + inline void _set_bit(int index) { + _has_bits_[index / 32] |= (1u << (index % 32)); + } + inline void _clear_bit(int index) { + _has_bits_[index / 32] &= ~(1u << (index % 32)); + } + + void InitAsDefaultInstance(); + static FileIndex* default_instance_; +}; +// ------------------------------------------------------------------- + +class AddressPart : public ::google::protobuf::MessageLite { + public: + AddressPart(); + virtual ~AddressPart(); + + AddressPart(const AddressPart& from); + + inline AddressPart& operator=(const AddressPart& from) { + CopyFrom(from); + return *this; + } + + static const AddressPart& default_instance(); + + void Swap(AddressPart* other); + + // implements Message ---------------------------------------------- + + AddressPart* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const AddressPart& from); + void MergeFrom(const AddressPart& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required int64 size = 1; + inline bool has_size() const; + inline void clear_size(); + static const int kSizeFieldNumber = 1; + inline ::google::protobuf::int64 size() const; + inline void set_size(::google::protobuf::int64 value); + + // required int64 offset = 2; + inline bool has_offset() const; + inline void clear_offset(); + static const int kOffsetFieldNumber = 2; + inline ::google::protobuf::int64 offset() const; + inline void set_offset(::google::protobuf::int64 value); + + // optional string name = 3; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 3; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const char* value, size_t size); + inline ::std::string* mutable_name(); + + // optional string nameEn = 4; + inline bool has_nameen() const; + inline void clear_nameen(); + static const int kNameEnFieldNumber = 4; + inline const ::std::string& nameen() const; + inline void set_nameen(const ::std::string& value); + inline void set_nameen(const char* value); + inline void set_nameen(const char* value, size_t size); + inline ::std::string* mutable_nameen(); + + // optional int32 indexNameOffset = 5; + inline bool has_indexnameoffset() const; + inline void clear_indexnameoffset(); + static const int kIndexNameOffsetFieldNumber = 5; + inline ::google::protobuf::int32 indexnameoffset() const; + inline void set_indexnameoffset(::google::protobuf::int32 value); + + // repeated .CityBlock cities = 8; + inline int cities_size() const; + inline void clear_cities(); + static const int kCitiesFieldNumber = 8; + inline const ::CityBlock& cities(int index) const; + inline ::CityBlock* mutable_cities(int index); + inline ::CityBlock* add_cities(); + inline const ::google::protobuf::RepeatedPtrField< ::CityBlock >& + cities() const; + inline ::google::protobuf::RepeatedPtrField< ::CityBlock >* + mutable_cities(); + + // @@protoc_insertion_point(class_scope:AddressPart) + private: + mutable int _cached_size_; + + ::google::protobuf::int64 size_; + ::google::protobuf::int64 offset_; + ::std::string* name_; + static const ::std::string _default_name_; + ::std::string* nameen_; + static const ::std::string _default_nameen_; + ::google::protobuf::int32 indexnameoffset_; + ::google::protobuf::RepeatedPtrField< ::CityBlock > cities_; + friend void protobuf_AddDesc_osmand_5findex_2eproto(); + friend void protobuf_AssignDesc_osmand_5findex_2eproto(); + friend void protobuf_ShutdownFile_osmand_5findex_2eproto(); + + ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32]; + + // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? + inline bool _has_bit(int index) const { + return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; + } + inline void _set_bit(int index) { + _has_bits_[index / 32] |= (1u << (index % 32)); + } + inline void _clear_bit(int index) { + _has_bits_[index / 32] &= ~(1u << (index % 32)); + } + + void InitAsDefaultInstance(); + static AddressPart* default_instance_; +}; +// ------------------------------------------------------------------- + +class CityBlock : public ::google::protobuf::MessageLite { + public: + CityBlock(); + virtual ~CityBlock(); + + CityBlock(const CityBlock& from); + + inline CityBlock& operator=(const CityBlock& from) { + CopyFrom(from); + return *this; + } + + static const CityBlock& default_instance(); + + void Swap(CityBlock* other); + + // implements Message ---------------------------------------------- + + CityBlock* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const CityBlock& from); + void MergeFrom(const CityBlock& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required int64 size = 1; + inline bool has_size() const; + inline void clear_size(); + static const int kSizeFieldNumber = 1; + inline ::google::protobuf::int64 size() const; + inline void set_size(::google::protobuf::int64 value); + + // required int64 offset = 2; + inline bool has_offset() const; + inline void clear_offset(); + static const int kOffsetFieldNumber = 2; + inline ::google::protobuf::int64 offset() const; + inline void set_offset(::google::protobuf::int64 value); + + // required int32 type = 3; + inline bool has_type() const; + inline void clear_type(); + static const int kTypeFieldNumber = 3; + inline ::google::protobuf::int32 type() const; + inline void set_type(::google::protobuf::int32 value); + + // @@protoc_insertion_point(class_scope:CityBlock) + private: + mutable int _cached_size_; + + ::google::protobuf::int64 size_; + ::google::protobuf::int64 offset_; + ::google::protobuf::int32 type_; + friend void protobuf_AddDesc_osmand_5findex_2eproto(); + friend void protobuf_AssignDesc_osmand_5findex_2eproto(); + friend void protobuf_ShutdownFile_osmand_5findex_2eproto(); + + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? + inline bool _has_bit(int index) const { + return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; + } + inline void _set_bit(int index) { + _has_bits_[index / 32] |= (1u << (index % 32)); + } + inline void _clear_bit(int index) { + _has_bits_[index / 32] &= ~(1u << (index % 32)); + } + + void InitAsDefaultInstance(); + static CityBlock* default_instance_; +}; +// ------------------------------------------------------------------- + +class PoiPart : public ::google::protobuf::MessageLite { + public: + PoiPart(); + virtual ~PoiPart(); + + PoiPart(const PoiPart& from); + + inline PoiPart& operator=(const PoiPart& from) { + CopyFrom(from); + return *this; + } + + static const PoiPart& default_instance(); + + void Swap(PoiPart* other); + + // implements Message ---------------------------------------------- + + PoiPart* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const PoiPart& from); + void MergeFrom(const PoiPart& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required int64 size = 1; + inline bool has_size() const; + inline void clear_size(); + static const int kSizeFieldNumber = 1; + inline ::google::protobuf::int64 size() const; + inline void set_size(::google::protobuf::int64 value); + + // required int64 offset = 2; + inline bool has_offset() const; + inline void clear_offset(); + static const int kOffsetFieldNumber = 2; + inline ::google::protobuf::int64 offset() const; + inline void set_offset(::google::protobuf::int64 value); + + // optional string name = 3; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 3; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const char* value, size_t size); + inline ::std::string* mutable_name(); + + // required int32 left = 4; + inline bool has_left() const; + inline void clear_left(); + static const int kLeftFieldNumber = 4; + inline ::google::protobuf::int32 left() const; + inline void set_left(::google::protobuf::int32 value); + + // required int32 right = 5; + inline bool has_right() const; + inline void clear_right(); + static const int kRightFieldNumber = 5; + inline ::google::protobuf::int32 right() const; + inline void set_right(::google::protobuf::int32 value); + + // required int32 top = 6; + inline bool has_top() const; + inline void clear_top(); + static const int kTopFieldNumber = 6; + inline ::google::protobuf::int32 top() const; + inline void set_top(::google::protobuf::int32 value); + + // required int32 bottom = 7; + inline bool has_bottom() const; + inline void clear_bottom(); + static const int kBottomFieldNumber = 7; + inline ::google::protobuf::int32 bottom() const; + inline void set_bottom(::google::protobuf::int32 value); + + // @@protoc_insertion_point(class_scope:PoiPart) + private: + mutable int _cached_size_; + + ::google::protobuf::int64 size_; + ::google::protobuf::int64 offset_; + ::std::string* name_; + static const ::std::string _default_name_; + ::google::protobuf::int32 left_; + ::google::protobuf::int32 right_; + ::google::protobuf::int32 top_; + ::google::protobuf::int32 bottom_; + friend void protobuf_AddDesc_osmand_5findex_2eproto(); + friend void protobuf_AssignDesc_osmand_5findex_2eproto(); + friend void protobuf_ShutdownFile_osmand_5findex_2eproto(); + + ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32]; + + // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? + inline bool _has_bit(int index) const { + return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; + } + inline void _set_bit(int index) { + _has_bits_[index / 32] |= (1u << (index % 32)); + } + inline void _clear_bit(int index) { + _has_bits_[index / 32] &= ~(1u << (index % 32)); + } + + void InitAsDefaultInstance(); + static PoiPart* default_instance_; +}; +// ------------------------------------------------------------------- + +class MapLevel : public ::google::protobuf::MessageLite { + public: + MapLevel(); + virtual ~MapLevel(); + + MapLevel(const MapLevel& from); + + inline MapLevel& operator=(const MapLevel& from) { + CopyFrom(from); + return *this; + } + + static const MapLevel& default_instance(); + + void Swap(MapLevel* other); + + // implements Message ---------------------------------------------- + + MapLevel* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const MapLevel& from); + void MergeFrom(const MapLevel& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required int64 size = 1; + inline bool has_size() const; + inline void clear_size(); + static const int kSizeFieldNumber = 1; + inline ::google::protobuf::int64 size() const; + inline void set_size(::google::protobuf::int64 value); + + // required int64 offset = 2; + inline bool has_offset() const; + inline void clear_offset(); + static const int kOffsetFieldNumber = 2; + inline ::google::protobuf::int64 offset() const; + inline void set_offset(::google::protobuf::int64 value); + + // required int32 left = 4; + inline bool has_left() const; + inline void clear_left(); + static const int kLeftFieldNumber = 4; + inline ::google::protobuf::int32 left() const; + inline void set_left(::google::protobuf::int32 value); + + // required int32 right = 5; + inline bool has_right() const; + inline void clear_right(); + static const int kRightFieldNumber = 5; + inline ::google::protobuf::int32 right() const; + inline void set_right(::google::protobuf::int32 value); + + // required int32 top = 6; + inline bool has_top() const; + inline void clear_top(); + static const int kTopFieldNumber = 6; + inline ::google::protobuf::int32 top() const; + inline void set_top(::google::protobuf::int32 value); + + // required int32 bottom = 7; + inline bool has_bottom() const; + inline void clear_bottom(); + static const int kBottomFieldNumber = 7; + inline ::google::protobuf::int32 bottom() const; + inline void set_bottom(::google::protobuf::int32 value); + + // optional int32 minzoom = 8; + inline bool has_minzoom() const; + inline void clear_minzoom(); + static const int kMinzoomFieldNumber = 8; + inline ::google::protobuf::int32 minzoom() const; + inline void set_minzoom(::google::protobuf::int32 value); + + // optional int32 maxzoom = 9; + inline bool has_maxzoom() const; + inline void clear_maxzoom(); + static const int kMaxzoomFieldNumber = 9; + inline ::google::protobuf::int32 maxzoom() const; + inline void set_maxzoom(::google::protobuf::int32 value); + + // @@protoc_insertion_point(class_scope:MapLevel) + private: + mutable int _cached_size_; + + ::google::protobuf::int64 size_; + ::google::protobuf::int64 offset_; + ::google::protobuf::int32 left_; + ::google::protobuf::int32 right_; + ::google::protobuf::int32 top_; + ::google::protobuf::int32 bottom_; + ::google::protobuf::int32 minzoom_; + ::google::protobuf::int32 maxzoom_; + friend void protobuf_AddDesc_osmand_5findex_2eproto(); + friend void protobuf_AssignDesc_osmand_5findex_2eproto(); + friend void protobuf_ShutdownFile_osmand_5findex_2eproto(); + + ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32]; + + // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? + inline bool _has_bit(int index) const { + return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; + } + inline void _set_bit(int index) { + _has_bits_[index / 32] |= (1u << (index % 32)); + } + inline void _clear_bit(int index) { + _has_bits_[index / 32] &= ~(1u << (index % 32)); + } + + void InitAsDefaultInstance(); + static MapLevel* default_instance_; +}; +// ------------------------------------------------------------------- + +class MapPart : public ::google::protobuf::MessageLite { + public: + MapPart(); + virtual ~MapPart(); + + MapPart(const MapPart& from); + + inline MapPart& operator=(const MapPart& from) { + CopyFrom(from); + return *this; + } + + static const MapPart& default_instance(); + + void Swap(MapPart* other); + + // implements Message ---------------------------------------------- + + MapPart* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const MapPart& from); + void MergeFrom(const MapPart& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required int64 size = 1; + inline bool has_size() const; + inline void clear_size(); + static const int kSizeFieldNumber = 1; + inline ::google::protobuf::int64 size() const; + inline void set_size(::google::protobuf::int64 value); + + // required int64 offset = 2; + inline bool has_offset() const; + inline void clear_offset(); + static const int kOffsetFieldNumber = 2; + inline ::google::protobuf::int64 offset() const; + inline void set_offset(::google::protobuf::int64 value); + + // optional string name = 3; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 3; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const char* value, size_t size); + inline ::std::string* mutable_name(); + + // repeated .MapLevel levels = 5; + inline int levels_size() const; + inline void clear_levels(); + static const int kLevelsFieldNumber = 5; + inline const ::MapLevel& levels(int index) const; + inline ::MapLevel* mutable_levels(int index); + inline ::MapLevel* add_levels(); + inline const ::google::protobuf::RepeatedPtrField< ::MapLevel >& + levels() const; + inline ::google::protobuf::RepeatedPtrField< ::MapLevel >* + mutable_levels(); + + // @@protoc_insertion_point(class_scope:MapPart) + private: + mutable int _cached_size_; + + ::google::protobuf::int64 size_; + ::google::protobuf::int64 offset_; + ::std::string* name_; + static const ::std::string _default_name_; + ::google::protobuf::RepeatedPtrField< ::MapLevel > levels_; + friend void protobuf_AddDesc_osmand_5findex_2eproto(); + friend void protobuf_AssignDesc_osmand_5findex_2eproto(); + friend void protobuf_ShutdownFile_osmand_5findex_2eproto(); + + ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; + + // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? + inline bool _has_bit(int index) const { + return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; + } + inline void _set_bit(int index) { + _has_bits_[index / 32] |= (1u << (index % 32)); + } + inline void _clear_bit(int index) { + _has_bits_[index / 32] &= ~(1u << (index % 32)); + } + + void InitAsDefaultInstance(); + static MapPart* default_instance_; +}; +// ------------------------------------------------------------------- + +class RoutingSubregion : public ::google::protobuf::MessageLite { + public: + RoutingSubregion(); + virtual ~RoutingSubregion(); + + RoutingSubregion(const RoutingSubregion& from); + + inline RoutingSubregion& operator=(const RoutingSubregion& from) { + CopyFrom(from); + return *this; + } + + static const RoutingSubregion& default_instance(); + + void Swap(RoutingSubregion* other); + + // implements Message ---------------------------------------------- + + RoutingSubregion* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const RoutingSubregion& from); + void MergeFrom(const RoutingSubregion& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required int64 size = 1; + inline bool has_size() const; + inline void clear_size(); + static const int kSizeFieldNumber = 1; + inline ::google::protobuf::int64 size() const; + inline void set_size(::google::protobuf::int64 value); + + // required int64 offset = 2; + inline bool has_offset() const; + inline void clear_offset(); + static const int kOffsetFieldNumber = 2; + inline ::google::protobuf::int64 offset() const; + inline void set_offset(::google::protobuf::int64 value); + + // required int32 left = 4; + inline bool has_left() const; + inline void clear_left(); + static const int kLeftFieldNumber = 4; + inline ::google::protobuf::int32 left() const; + inline void set_left(::google::protobuf::int32 value); + + // required int32 right = 5; + inline bool has_right() const; + inline void clear_right(); + static const int kRightFieldNumber = 5; + inline ::google::protobuf::int32 right() const; + inline void set_right(::google::protobuf::int32 value); + + // required int32 top = 6; + inline bool has_top() const; + inline void clear_top(); + static const int kTopFieldNumber = 6; + inline ::google::protobuf::int32 top() const; + inline void set_top(::google::protobuf::int32 value); + + // required int32 bottom = 7; + inline bool has_bottom() const; + inline void clear_bottom(); + static const int kBottomFieldNumber = 7; + inline ::google::protobuf::int32 bottom() const; + inline void set_bottom(::google::protobuf::int32 value); + + // required uint32 shifToData = 8; + inline bool has_shiftodata() const; + inline void clear_shiftodata(); + static const int kShifToDataFieldNumber = 8; + inline ::google::protobuf::uint32 shiftodata() const; + inline void set_shiftodata(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:RoutingSubregion) + private: + mutable int _cached_size_; + + ::google::protobuf::int64 size_; + ::google::protobuf::int64 offset_; + ::google::protobuf::int32 left_; + ::google::protobuf::int32 right_; + ::google::protobuf::int32 top_; + ::google::protobuf::int32 bottom_; + ::google::protobuf::uint32 shiftodata_; + friend void protobuf_AddDesc_osmand_5findex_2eproto(); + friend void protobuf_AssignDesc_osmand_5findex_2eproto(); + friend void protobuf_ShutdownFile_osmand_5findex_2eproto(); + + ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32]; + + // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? + inline bool _has_bit(int index) const { + return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; + } + inline void _set_bit(int index) { + _has_bits_[index / 32] |= (1u << (index % 32)); + } + inline void _clear_bit(int index) { + _has_bits_[index / 32] &= ~(1u << (index % 32)); + } + + void InitAsDefaultInstance(); + static RoutingSubregion* default_instance_; +}; +// ------------------------------------------------------------------- + +class RoutingPart : public ::google::protobuf::MessageLite { + public: + RoutingPart(); + virtual ~RoutingPart(); + + RoutingPart(const RoutingPart& from); + + inline RoutingPart& operator=(const RoutingPart& from) { + CopyFrom(from); + return *this; + } + + static const RoutingPart& default_instance(); + + void Swap(RoutingPart* other); + + // implements Message ---------------------------------------------- + + RoutingPart* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const RoutingPart& from); + void MergeFrom(const RoutingPart& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required int64 size = 1; + inline bool has_size() const; + inline void clear_size(); + static const int kSizeFieldNumber = 1; + inline ::google::protobuf::int64 size() const; + inline void set_size(::google::protobuf::int64 value); + + // required int64 offset = 2; + inline bool has_offset() const; + inline void clear_offset(); + static const int kOffsetFieldNumber = 2; + inline ::google::protobuf::int64 offset() const; + inline void set_offset(::google::protobuf::int64 value); + + // optional string name = 3; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 3; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const char* value, size_t size); + inline ::std::string* mutable_name(); + + // repeated .RoutingSubregion subregions = 5; + inline int subregions_size() const; + inline void clear_subregions(); + static const int kSubregionsFieldNumber = 5; + inline const ::RoutingSubregion& subregions(int index) const; + inline ::RoutingSubregion* mutable_subregions(int index); + inline ::RoutingSubregion* add_subregions(); + inline const ::google::protobuf::RepeatedPtrField< ::RoutingSubregion >& + subregions() const; + inline ::google::protobuf::RepeatedPtrField< ::RoutingSubregion >* + mutable_subregions(); + + // @@protoc_insertion_point(class_scope:RoutingPart) + private: + mutable int _cached_size_; + + ::google::protobuf::int64 size_; + ::google::protobuf::int64 offset_; + ::std::string* name_; + static const ::std::string _default_name_; + ::google::protobuf::RepeatedPtrField< ::RoutingSubregion > subregions_; + friend void protobuf_AddDesc_osmand_5findex_2eproto(); + friend void protobuf_AssignDesc_osmand_5findex_2eproto(); + friend void protobuf_ShutdownFile_osmand_5findex_2eproto(); + + ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; + + // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? + inline bool _has_bit(int index) const { + return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; + } + inline void _set_bit(int index) { + _has_bits_[index / 32] |= (1u << (index % 32)); + } + inline void _clear_bit(int index) { + _has_bits_[index / 32] &= ~(1u << (index % 32)); + } + + void InitAsDefaultInstance(); + static RoutingPart* default_instance_; +}; +// ------------------------------------------------------------------- + +class TransportPart : public ::google::protobuf::MessageLite { + public: + TransportPart(); + virtual ~TransportPart(); + + TransportPart(const TransportPart& from); + + inline TransportPart& operator=(const TransportPart& from) { + CopyFrom(from); + return *this; + } + + static const TransportPart& default_instance(); + + void Swap(TransportPart* other); + + // implements Message ---------------------------------------------- + + TransportPart* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const TransportPart& from); + void MergeFrom(const TransportPart& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required int64 size = 1; + inline bool has_size() const; + inline void clear_size(); + static const int kSizeFieldNumber = 1; + inline ::google::protobuf::int64 size() const; + inline void set_size(::google::protobuf::int64 value); + + // required int64 offset = 2; + inline bool has_offset() const; + inline void clear_offset(); + static const int kOffsetFieldNumber = 2; + inline ::google::protobuf::int64 offset() const; + inline void set_offset(::google::protobuf::int64 value); + + // optional string name = 3; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 3; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const char* value, size_t size); + inline ::std::string* mutable_name(); + + // optional int32 left = 4; + inline bool has_left() const; + inline void clear_left(); + static const int kLeftFieldNumber = 4; + inline ::google::protobuf::int32 left() const; + inline void set_left(::google::protobuf::int32 value); + + // optional int32 right = 5; + inline bool has_right() const; + inline void clear_right(); + static const int kRightFieldNumber = 5; + inline ::google::protobuf::int32 right() const; + inline void set_right(::google::protobuf::int32 value); + + // optional int32 top = 6; + inline bool has_top() const; + inline void clear_top(); + static const int kTopFieldNumber = 6; + inline ::google::protobuf::int32 top() const; + inline void set_top(::google::protobuf::int32 value); + + // optional int32 bottom = 7; + inline bool has_bottom() const; + inline void clear_bottom(); + static const int kBottomFieldNumber = 7; + inline ::google::protobuf::int32 bottom() const; + inline void set_bottom(::google::protobuf::int32 value); + + // optional uint32 stringTableOffset = 8; + inline bool has_stringtableoffset() const; + inline void clear_stringtableoffset(); + static const int kStringTableOffsetFieldNumber = 8; + inline ::google::protobuf::uint32 stringtableoffset() const; + inline void set_stringtableoffset(::google::protobuf::uint32 value); + + // optional uint32 stringTableLength = 9; + inline bool has_stringtablelength() const; + inline void clear_stringtablelength(); + static const int kStringTableLengthFieldNumber = 9; + inline ::google::protobuf::uint32 stringtablelength() const; + inline void set_stringtablelength(::google::protobuf::uint32 value); + + // optional uint32 stopsTableOffset = 10; + inline bool has_stopstableoffset() const; + inline void clear_stopstableoffset(); + static const int kStopsTableOffsetFieldNumber = 10; + inline ::google::protobuf::uint32 stopstableoffset() const; + inline void set_stopstableoffset(::google::protobuf::uint32 value); + + // optional uint32 stopsTableLength = 11; + inline bool has_stopstablelength() const; + inline void clear_stopstablelength(); + static const int kStopsTableLengthFieldNumber = 11; + inline ::google::protobuf::uint32 stopstablelength() const; + inline void set_stopstablelength(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:TransportPart) + private: + mutable int _cached_size_; + + ::google::protobuf::int64 size_; + ::google::protobuf::int64 offset_; + ::std::string* name_; + static const ::std::string _default_name_; + ::google::protobuf::int32 left_; + ::google::protobuf::int32 right_; + ::google::protobuf::int32 top_; + ::google::protobuf::int32 bottom_; + ::google::protobuf::uint32 stringtableoffset_; + ::google::protobuf::uint32 stringtablelength_; + ::google::protobuf::uint32 stopstableoffset_; + ::google::protobuf::uint32 stopstablelength_; + friend void protobuf_AddDesc_osmand_5findex_2eproto(); + friend void protobuf_AssignDesc_osmand_5findex_2eproto(); + friend void protobuf_ShutdownFile_osmand_5findex_2eproto(); + + ::google::protobuf::uint32 _has_bits_[(11 + 31) / 32]; + + // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? + inline bool _has_bit(int index) const { + return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; + } + inline void _set_bit(int index) { + _has_bits_[index / 32] |= (1u << (index % 32)); + } + inline void _clear_bit(int index) { + _has_bits_[index / 32] &= ~(1u << (index % 32)); + } + + void InitAsDefaultInstance(); + static TransportPart* default_instance_; +}; +// =================================================================== + + +// =================================================================== + +// OsmAndStoredIndex + +// required uint32 version = 1; +inline bool OsmAndStoredIndex::has_version() const { + return _has_bit(0); +} +inline void OsmAndStoredIndex::clear_version() { + version_ = 0u; + _clear_bit(0); +} +inline ::google::protobuf::uint32 OsmAndStoredIndex::version() const { + return version_; +} +inline void OsmAndStoredIndex::set_version(::google::protobuf::uint32 value) { + _set_bit(0); + version_ = value; +} + +// required int64 dateCreated = 18; +inline bool OsmAndStoredIndex::has_datecreated() const { + return _has_bit(1); +} +inline void OsmAndStoredIndex::clear_datecreated() { + datecreated_ = GOOGLE_LONGLONG(0); + _clear_bit(1); +} +inline ::google::protobuf::int64 OsmAndStoredIndex::datecreated() const { + return datecreated_; +} +inline void OsmAndStoredIndex::set_datecreated(::google::protobuf::int64 value) { + _set_bit(1); + datecreated_ = value; +} + +// repeated .FileIndex fileIndex = 7; +inline int OsmAndStoredIndex::fileindex_size() const { + return fileindex_.size(); +} +inline void OsmAndStoredIndex::clear_fileindex() { + fileindex_.Clear(); +} +inline const ::FileIndex& OsmAndStoredIndex::fileindex(int index) const { + return fileindex_.Get(index); +} +inline ::FileIndex* OsmAndStoredIndex::mutable_fileindex(int index) { + return fileindex_.Mutable(index); +} +inline ::FileIndex* OsmAndStoredIndex::add_fileindex() { + return fileindex_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::FileIndex >& +OsmAndStoredIndex::fileindex() const { + return fileindex_; +} +inline ::google::protobuf::RepeatedPtrField< ::FileIndex >* +OsmAndStoredIndex::mutable_fileindex() { + return &fileindex_; +} + +// ------------------------------------------------------------------- + +// FileIndex + +// required int64 size = 1; +inline bool FileIndex::has_size() const { + return _has_bit(0); +} +inline void FileIndex::clear_size() { + size_ = GOOGLE_LONGLONG(0); + _clear_bit(0); +} +inline ::google::protobuf::int64 FileIndex::size() const { + return size_; +} +inline void FileIndex::set_size(::google::protobuf::int64 value) { + _set_bit(0); + size_ = value; +} + +// required int64 dateModified = 2; +inline bool FileIndex::has_datemodified() const { + return _has_bit(1); +} +inline void FileIndex::clear_datemodified() { + datemodified_ = GOOGLE_LONGLONG(0); + _clear_bit(1); +} +inline ::google::protobuf::int64 FileIndex::datemodified() const { + return datemodified_; +} +inline void FileIndex::set_datemodified(::google::protobuf::int64 value) { + _set_bit(1); + datemodified_ = value; +} + +// required string fileName = 3; +inline bool FileIndex::has_filename() const { + return _has_bit(2); +} +inline void FileIndex::clear_filename() { + if (filename_ != &_default_filename_) { + filename_->clear(); + } + _clear_bit(2); +} +inline const ::std::string& FileIndex::filename() const { + return *filename_; +} +inline void FileIndex::set_filename(const ::std::string& value) { + _set_bit(2); + if (filename_ == &_default_filename_) { + filename_ = new ::std::string; + } + filename_->assign(value); +} +inline void FileIndex::set_filename(const char* value) { + _set_bit(2); + if (filename_ == &_default_filename_) { + filename_ = new ::std::string; + } + filename_->assign(value); +} +inline void FileIndex::set_filename(const char* value, size_t size) { + _set_bit(2); + if (filename_ == &_default_filename_) { + filename_ = new ::std::string; + } + filename_->assign(reinterpret_cast(value), size); +} +inline ::std::string* FileIndex::mutable_filename() { + _set_bit(2); + if (filename_ == &_default_filename_) { + filename_ = new ::std::string; + } + return filename_; +} + +// required int32 version = 4; +inline bool FileIndex::has_version() const { + return _has_bit(3); +} +inline void FileIndex::clear_version() { + version_ = 0; + _clear_bit(3); +} +inline ::google::protobuf::int32 FileIndex::version() const { + return version_; +} +inline void FileIndex::set_version(::google::protobuf::int32 value) { + _set_bit(3); + version_ = value; +} + +// repeated .AddressPart addressIndex = 8; +inline int FileIndex::addressindex_size() const { + return addressindex_.size(); +} +inline void FileIndex::clear_addressindex() { + addressindex_.Clear(); +} +inline const ::AddressPart& FileIndex::addressindex(int index) const { + return addressindex_.Get(index); +} +inline ::AddressPart* FileIndex::mutable_addressindex(int index) { + return addressindex_.Mutable(index); +} +inline ::AddressPart* FileIndex::add_addressindex() { + return addressindex_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::AddressPart >& +FileIndex::addressindex() const { + return addressindex_; +} +inline ::google::protobuf::RepeatedPtrField< ::AddressPart >* +FileIndex::mutable_addressindex() { + return &addressindex_; +} + +// repeated .TransportPart transportIndex = 9; +inline int FileIndex::transportindex_size() const { + return transportindex_.size(); +} +inline void FileIndex::clear_transportindex() { + transportindex_.Clear(); +} +inline const ::TransportPart& FileIndex::transportindex(int index) const { + return transportindex_.Get(index); +} +inline ::TransportPart* FileIndex::mutable_transportindex(int index) { + return transportindex_.Mutable(index); +} +inline ::TransportPart* FileIndex::add_transportindex() { + return transportindex_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::TransportPart >& +FileIndex::transportindex() const { + return transportindex_; +} +inline ::google::protobuf::RepeatedPtrField< ::TransportPart >* +FileIndex::mutable_transportindex() { + return &transportindex_; +} + +// repeated .PoiPart poiIndex = 10; +inline int FileIndex::poiindex_size() const { + return poiindex_.size(); +} +inline void FileIndex::clear_poiindex() { + poiindex_.Clear(); +} +inline const ::PoiPart& FileIndex::poiindex(int index) const { + return poiindex_.Get(index); +} +inline ::PoiPart* FileIndex::mutable_poiindex(int index) { + return poiindex_.Mutable(index); +} +inline ::PoiPart* FileIndex::add_poiindex() { + return poiindex_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::PoiPart >& +FileIndex::poiindex() const { + return poiindex_; +} +inline ::google::protobuf::RepeatedPtrField< ::PoiPart >* +FileIndex::mutable_poiindex() { + return &poiindex_; +} + +// repeated .MapPart mapIndex = 11; +inline int FileIndex::mapindex_size() const { + return mapindex_.size(); +} +inline void FileIndex::clear_mapindex() { + mapindex_.Clear(); +} +inline const ::MapPart& FileIndex::mapindex(int index) const { + return mapindex_.Get(index); +} +inline ::MapPart* FileIndex::mutable_mapindex(int index) { + return mapindex_.Mutable(index); +} +inline ::MapPart* FileIndex::add_mapindex() { + return mapindex_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::MapPart >& +FileIndex::mapindex() const { + return mapindex_; +} +inline ::google::protobuf::RepeatedPtrField< ::MapPart >* +FileIndex::mutable_mapindex() { + return &mapindex_; +} + +// repeated .RoutingPart routingIndex = 12; +inline int FileIndex::routingindex_size() const { + return routingindex_.size(); +} +inline void FileIndex::clear_routingindex() { + routingindex_.Clear(); +} +inline const ::RoutingPart& FileIndex::routingindex(int index) const { + return routingindex_.Get(index); +} +inline ::RoutingPart* FileIndex::mutable_routingindex(int index) { + return routingindex_.Mutable(index); +} +inline ::RoutingPart* FileIndex::add_routingindex() { + return routingindex_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::RoutingPart >& +FileIndex::routingindex() const { + return routingindex_; +} +inline ::google::protobuf::RepeatedPtrField< ::RoutingPart >* +FileIndex::mutable_routingindex() { + return &routingindex_; +} + +// ------------------------------------------------------------------- + +// AddressPart + +// required int64 size = 1; +inline bool AddressPart::has_size() const { + return _has_bit(0); +} +inline void AddressPart::clear_size() { + size_ = GOOGLE_LONGLONG(0); + _clear_bit(0); +} +inline ::google::protobuf::int64 AddressPart::size() const { + return size_; +} +inline void AddressPart::set_size(::google::protobuf::int64 value) { + _set_bit(0); + size_ = value; +} + +// required int64 offset = 2; +inline bool AddressPart::has_offset() const { + return _has_bit(1); +} +inline void AddressPart::clear_offset() { + offset_ = GOOGLE_LONGLONG(0); + _clear_bit(1); +} +inline ::google::protobuf::int64 AddressPart::offset() const { + return offset_; +} +inline void AddressPart::set_offset(::google::protobuf::int64 value) { + _set_bit(1); + offset_ = value; +} + +// optional string name = 3; +inline bool AddressPart::has_name() const { + return _has_bit(2); +} +inline void AddressPart::clear_name() { + if (name_ != &_default_name_) { + name_->clear(); + } + _clear_bit(2); +} +inline const ::std::string& AddressPart::name() const { + return *name_; +} +inline void AddressPart::set_name(const ::std::string& value) { + _set_bit(2); + if (name_ == &_default_name_) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void AddressPart::set_name(const char* value) { + _set_bit(2); + if (name_ == &_default_name_) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void AddressPart::set_name(const char* value, size_t size) { + _set_bit(2); + if (name_ == &_default_name_) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* AddressPart::mutable_name() { + _set_bit(2); + if (name_ == &_default_name_) { + name_ = new ::std::string; + } + return name_; +} + +// optional string nameEn = 4; +inline bool AddressPart::has_nameen() const { + return _has_bit(3); +} +inline void AddressPart::clear_nameen() { + if (nameen_ != &_default_nameen_) { + nameen_->clear(); + } + _clear_bit(3); +} +inline const ::std::string& AddressPart::nameen() const { + return *nameen_; +} +inline void AddressPart::set_nameen(const ::std::string& value) { + _set_bit(3); + if (nameen_ == &_default_nameen_) { + nameen_ = new ::std::string; + } + nameen_->assign(value); +} +inline void AddressPart::set_nameen(const char* value) { + _set_bit(3); + if (nameen_ == &_default_nameen_) { + nameen_ = new ::std::string; + } + nameen_->assign(value); +} +inline void AddressPart::set_nameen(const char* value, size_t size) { + _set_bit(3); + if (nameen_ == &_default_nameen_) { + nameen_ = new ::std::string; + } + nameen_->assign(reinterpret_cast(value), size); +} +inline ::std::string* AddressPart::mutable_nameen() { + _set_bit(3); + if (nameen_ == &_default_nameen_) { + nameen_ = new ::std::string; + } + return nameen_; +} + +// optional int32 indexNameOffset = 5; +inline bool AddressPart::has_indexnameoffset() const { + return _has_bit(4); +} +inline void AddressPart::clear_indexnameoffset() { + indexnameoffset_ = 0; + _clear_bit(4); +} +inline ::google::protobuf::int32 AddressPart::indexnameoffset() const { + return indexnameoffset_; +} +inline void AddressPart::set_indexnameoffset(::google::protobuf::int32 value) { + _set_bit(4); + indexnameoffset_ = value; +} + +// repeated .CityBlock cities = 8; +inline int AddressPart::cities_size() const { + return cities_.size(); +} +inline void AddressPart::clear_cities() { + cities_.Clear(); +} +inline const ::CityBlock& AddressPart::cities(int index) const { + return cities_.Get(index); +} +inline ::CityBlock* AddressPart::mutable_cities(int index) { + return cities_.Mutable(index); +} +inline ::CityBlock* AddressPart::add_cities() { + return cities_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::CityBlock >& +AddressPart::cities() const { + return cities_; +} +inline ::google::protobuf::RepeatedPtrField< ::CityBlock >* +AddressPart::mutable_cities() { + return &cities_; +} + +// ------------------------------------------------------------------- + +// CityBlock + +// required int64 size = 1; +inline bool CityBlock::has_size() const { + return _has_bit(0); +} +inline void CityBlock::clear_size() { + size_ = GOOGLE_LONGLONG(0); + _clear_bit(0); +} +inline ::google::protobuf::int64 CityBlock::size() const { + return size_; +} +inline void CityBlock::set_size(::google::protobuf::int64 value) { + _set_bit(0); + size_ = value; +} + +// required int64 offset = 2; +inline bool CityBlock::has_offset() const { + return _has_bit(1); +} +inline void CityBlock::clear_offset() { + offset_ = GOOGLE_LONGLONG(0); + _clear_bit(1); +} +inline ::google::protobuf::int64 CityBlock::offset() const { + return offset_; +} +inline void CityBlock::set_offset(::google::protobuf::int64 value) { + _set_bit(1); + offset_ = value; +} + +// required int32 type = 3; +inline bool CityBlock::has_type() const { + return _has_bit(2); +} +inline void CityBlock::clear_type() { + type_ = 0; + _clear_bit(2); +} +inline ::google::protobuf::int32 CityBlock::type() const { + return type_; +} +inline void CityBlock::set_type(::google::protobuf::int32 value) { + _set_bit(2); + type_ = value; +} + +// ------------------------------------------------------------------- + +// PoiPart + +// required int64 size = 1; +inline bool PoiPart::has_size() const { + return _has_bit(0); +} +inline void PoiPart::clear_size() { + size_ = GOOGLE_LONGLONG(0); + _clear_bit(0); +} +inline ::google::protobuf::int64 PoiPart::size() const { + return size_; +} +inline void PoiPart::set_size(::google::protobuf::int64 value) { + _set_bit(0); + size_ = value; +} + +// required int64 offset = 2; +inline bool PoiPart::has_offset() const { + return _has_bit(1); +} +inline void PoiPart::clear_offset() { + offset_ = GOOGLE_LONGLONG(0); + _clear_bit(1); +} +inline ::google::protobuf::int64 PoiPart::offset() const { + return offset_; +} +inline void PoiPart::set_offset(::google::protobuf::int64 value) { + _set_bit(1); + offset_ = value; +} + +// optional string name = 3; +inline bool PoiPart::has_name() const { + return _has_bit(2); +} +inline void PoiPart::clear_name() { + if (name_ != &_default_name_) { + name_->clear(); + } + _clear_bit(2); +} +inline const ::std::string& PoiPart::name() const { + return *name_; +} +inline void PoiPart::set_name(const ::std::string& value) { + _set_bit(2); + if (name_ == &_default_name_) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void PoiPart::set_name(const char* value) { + _set_bit(2); + if (name_ == &_default_name_) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void PoiPart::set_name(const char* value, size_t size) { + _set_bit(2); + if (name_ == &_default_name_) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* PoiPart::mutable_name() { + _set_bit(2); + if (name_ == &_default_name_) { + name_ = new ::std::string; + } + return name_; +} + +// required int32 left = 4; +inline bool PoiPart::has_left() const { + return _has_bit(3); +} +inline void PoiPart::clear_left() { + left_ = 0; + _clear_bit(3); +} +inline ::google::protobuf::int32 PoiPart::left() const { + return left_; +} +inline void PoiPart::set_left(::google::protobuf::int32 value) { + _set_bit(3); + left_ = value; +} + +// required int32 right = 5; +inline bool PoiPart::has_right() const { + return _has_bit(4); +} +inline void PoiPart::clear_right() { + right_ = 0; + _clear_bit(4); +} +inline ::google::protobuf::int32 PoiPart::right() const { + return right_; +} +inline void PoiPart::set_right(::google::protobuf::int32 value) { + _set_bit(4); + right_ = value; +} + +// required int32 top = 6; +inline bool PoiPart::has_top() const { + return _has_bit(5); +} +inline void PoiPart::clear_top() { + top_ = 0; + _clear_bit(5); +} +inline ::google::protobuf::int32 PoiPart::top() const { + return top_; +} +inline void PoiPart::set_top(::google::protobuf::int32 value) { + _set_bit(5); + top_ = value; +} + +// required int32 bottom = 7; +inline bool PoiPart::has_bottom() const { + return _has_bit(6); +} +inline void PoiPart::clear_bottom() { + bottom_ = 0; + _clear_bit(6); +} +inline ::google::protobuf::int32 PoiPart::bottom() const { + return bottom_; +} +inline void PoiPart::set_bottom(::google::protobuf::int32 value) { + _set_bit(6); + bottom_ = value; +} + +// ------------------------------------------------------------------- + +// MapLevel + +// required int64 size = 1; +inline bool MapLevel::has_size() const { + return _has_bit(0); +} +inline void MapLevel::clear_size() { + size_ = GOOGLE_LONGLONG(0); + _clear_bit(0); +} +inline ::google::protobuf::int64 MapLevel::size() const { + return size_; +} +inline void MapLevel::set_size(::google::protobuf::int64 value) { + _set_bit(0); + size_ = value; +} + +// required int64 offset = 2; +inline bool MapLevel::has_offset() const { + return _has_bit(1); +} +inline void MapLevel::clear_offset() { + offset_ = GOOGLE_LONGLONG(0); + _clear_bit(1); +} +inline ::google::protobuf::int64 MapLevel::offset() const { + return offset_; +} +inline void MapLevel::set_offset(::google::protobuf::int64 value) { + _set_bit(1); + offset_ = value; +} + +// required int32 left = 4; +inline bool MapLevel::has_left() const { + return _has_bit(2); +} +inline void MapLevel::clear_left() { + left_ = 0; + _clear_bit(2); +} +inline ::google::protobuf::int32 MapLevel::left() const { + return left_; +} +inline void MapLevel::set_left(::google::protobuf::int32 value) { + _set_bit(2); + left_ = value; +} + +// required int32 right = 5; +inline bool MapLevel::has_right() const { + return _has_bit(3); +} +inline void MapLevel::clear_right() { + right_ = 0; + _clear_bit(3); +} +inline ::google::protobuf::int32 MapLevel::right() const { + return right_; +} +inline void MapLevel::set_right(::google::protobuf::int32 value) { + _set_bit(3); + right_ = value; +} + +// required int32 top = 6; +inline bool MapLevel::has_top() const { + return _has_bit(4); +} +inline void MapLevel::clear_top() { + top_ = 0; + _clear_bit(4); +} +inline ::google::protobuf::int32 MapLevel::top() const { + return top_; +} +inline void MapLevel::set_top(::google::protobuf::int32 value) { + _set_bit(4); + top_ = value; +} + +// required int32 bottom = 7; +inline bool MapLevel::has_bottom() const { + return _has_bit(5); +} +inline void MapLevel::clear_bottom() { + bottom_ = 0; + _clear_bit(5); +} +inline ::google::protobuf::int32 MapLevel::bottom() const { + return bottom_; +} +inline void MapLevel::set_bottom(::google::protobuf::int32 value) { + _set_bit(5); + bottom_ = value; +} + +// optional int32 minzoom = 8; +inline bool MapLevel::has_minzoom() const { + return _has_bit(6); +} +inline void MapLevel::clear_minzoom() { + minzoom_ = 0; + _clear_bit(6); +} +inline ::google::protobuf::int32 MapLevel::minzoom() const { + return minzoom_; +} +inline void MapLevel::set_minzoom(::google::protobuf::int32 value) { + _set_bit(6); + minzoom_ = value; +} + +// optional int32 maxzoom = 9; +inline bool MapLevel::has_maxzoom() const { + return _has_bit(7); +} +inline void MapLevel::clear_maxzoom() { + maxzoom_ = 0; + _clear_bit(7); +} +inline ::google::protobuf::int32 MapLevel::maxzoom() const { + return maxzoom_; +} +inline void MapLevel::set_maxzoom(::google::protobuf::int32 value) { + _set_bit(7); + maxzoom_ = value; +} + +// ------------------------------------------------------------------- + +// MapPart + +// required int64 size = 1; +inline bool MapPart::has_size() const { + return _has_bit(0); +} +inline void MapPart::clear_size() { + size_ = GOOGLE_LONGLONG(0); + _clear_bit(0); +} +inline ::google::protobuf::int64 MapPart::size() const { + return size_; +} +inline void MapPart::set_size(::google::protobuf::int64 value) { + _set_bit(0); + size_ = value; +} + +// required int64 offset = 2; +inline bool MapPart::has_offset() const { + return _has_bit(1); +} +inline void MapPart::clear_offset() { + offset_ = GOOGLE_LONGLONG(0); + _clear_bit(1); +} +inline ::google::protobuf::int64 MapPart::offset() const { + return offset_; +} +inline void MapPart::set_offset(::google::protobuf::int64 value) { + _set_bit(1); + offset_ = value; +} + +// optional string name = 3; +inline bool MapPart::has_name() const { + return _has_bit(2); +} +inline void MapPart::clear_name() { + if (name_ != &_default_name_) { + name_->clear(); + } + _clear_bit(2); +} +inline const ::std::string& MapPart::name() const { + return *name_; +} +inline void MapPart::set_name(const ::std::string& value) { + _set_bit(2); + if (name_ == &_default_name_) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void MapPart::set_name(const char* value) { + _set_bit(2); + if (name_ == &_default_name_) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void MapPart::set_name(const char* value, size_t size) { + _set_bit(2); + if (name_ == &_default_name_) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* MapPart::mutable_name() { + _set_bit(2); + if (name_ == &_default_name_) { + name_ = new ::std::string; + } + return name_; +} + +// repeated .MapLevel levels = 5; +inline int MapPart::levels_size() const { + return levels_.size(); +} +inline void MapPart::clear_levels() { + levels_.Clear(); +} +inline const ::MapLevel& MapPart::levels(int index) const { + return levels_.Get(index); +} +inline ::MapLevel* MapPart::mutable_levels(int index) { + return levels_.Mutable(index); +} +inline ::MapLevel* MapPart::add_levels() { + return levels_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::MapLevel >& +MapPart::levels() const { + return levels_; +} +inline ::google::protobuf::RepeatedPtrField< ::MapLevel >* +MapPart::mutable_levels() { + return &levels_; +} + +// ------------------------------------------------------------------- + +// RoutingSubregion + +// required int64 size = 1; +inline bool RoutingSubregion::has_size() const { + return _has_bit(0); +} +inline void RoutingSubregion::clear_size() { + size_ = GOOGLE_LONGLONG(0); + _clear_bit(0); +} +inline ::google::protobuf::int64 RoutingSubregion::size() const { + return size_; +} +inline void RoutingSubregion::set_size(::google::protobuf::int64 value) { + _set_bit(0); + size_ = value; +} + +// required int64 offset = 2; +inline bool RoutingSubregion::has_offset() const { + return _has_bit(1); +} +inline void RoutingSubregion::clear_offset() { + offset_ = GOOGLE_LONGLONG(0); + _clear_bit(1); +} +inline ::google::protobuf::int64 RoutingSubregion::offset() const { + return offset_; +} +inline void RoutingSubregion::set_offset(::google::protobuf::int64 value) { + _set_bit(1); + offset_ = value; +} + +// required int32 left = 4; +inline bool RoutingSubregion::has_left() const { + return _has_bit(2); +} +inline void RoutingSubregion::clear_left() { + left_ = 0; + _clear_bit(2); +} +inline ::google::protobuf::int32 RoutingSubregion::left() const { + return left_; +} +inline void RoutingSubregion::set_left(::google::protobuf::int32 value) { + _set_bit(2); + left_ = value; +} + +// required int32 right = 5; +inline bool RoutingSubregion::has_right() const { + return _has_bit(3); +} +inline void RoutingSubregion::clear_right() { + right_ = 0; + _clear_bit(3); +} +inline ::google::protobuf::int32 RoutingSubregion::right() const { + return right_; +} +inline void RoutingSubregion::set_right(::google::protobuf::int32 value) { + _set_bit(3); + right_ = value; +} + +// required int32 top = 6; +inline bool RoutingSubregion::has_top() const { + return _has_bit(4); +} +inline void RoutingSubregion::clear_top() { + top_ = 0; + _clear_bit(4); +} +inline ::google::protobuf::int32 RoutingSubregion::top() const { + return top_; +} +inline void RoutingSubregion::set_top(::google::protobuf::int32 value) { + _set_bit(4); + top_ = value; +} + +// required int32 bottom = 7; +inline bool RoutingSubregion::has_bottom() const { + return _has_bit(5); +} +inline void RoutingSubregion::clear_bottom() { + bottom_ = 0; + _clear_bit(5); +} +inline ::google::protobuf::int32 RoutingSubregion::bottom() const { + return bottom_; +} +inline void RoutingSubregion::set_bottom(::google::protobuf::int32 value) { + _set_bit(5); + bottom_ = value; +} + +// required uint32 shifToData = 8; +inline bool RoutingSubregion::has_shiftodata() const { + return _has_bit(6); +} +inline void RoutingSubregion::clear_shiftodata() { + shiftodata_ = 0u; + _clear_bit(6); +} +inline ::google::protobuf::uint32 RoutingSubregion::shiftodata() const { + return shiftodata_; +} +inline void RoutingSubregion::set_shiftodata(::google::protobuf::uint32 value) { + _set_bit(6); + shiftodata_ = value; +} + +// ------------------------------------------------------------------- + +// RoutingPart + +// required int64 size = 1; +inline bool RoutingPart::has_size() const { + return _has_bit(0); +} +inline void RoutingPart::clear_size() { + size_ = GOOGLE_LONGLONG(0); + _clear_bit(0); +} +inline ::google::protobuf::int64 RoutingPart::size() const { + return size_; +} +inline void RoutingPart::set_size(::google::protobuf::int64 value) { + _set_bit(0); + size_ = value; +} + +// required int64 offset = 2; +inline bool RoutingPart::has_offset() const { + return _has_bit(1); +} +inline void RoutingPart::clear_offset() { + offset_ = GOOGLE_LONGLONG(0); + _clear_bit(1); +} +inline ::google::protobuf::int64 RoutingPart::offset() const { + return offset_; +} +inline void RoutingPart::set_offset(::google::protobuf::int64 value) { + _set_bit(1); + offset_ = value; +} + +// optional string name = 3; +inline bool RoutingPart::has_name() const { + return _has_bit(2); +} +inline void RoutingPart::clear_name() { + if (name_ != &_default_name_) { + name_->clear(); + } + _clear_bit(2); +} +inline const ::std::string& RoutingPart::name() const { + return *name_; +} +inline void RoutingPart::set_name(const ::std::string& value) { + _set_bit(2); + if (name_ == &_default_name_) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void RoutingPart::set_name(const char* value) { + _set_bit(2); + if (name_ == &_default_name_) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void RoutingPart::set_name(const char* value, size_t size) { + _set_bit(2); + if (name_ == &_default_name_) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* RoutingPart::mutable_name() { + _set_bit(2); + if (name_ == &_default_name_) { + name_ = new ::std::string; + } + return name_; +} + +// repeated .RoutingSubregion subregions = 5; +inline int RoutingPart::subregions_size() const { + return subregions_.size(); +} +inline void RoutingPart::clear_subregions() { + subregions_.Clear(); +} +inline const ::RoutingSubregion& RoutingPart::subregions(int index) const { + return subregions_.Get(index); +} +inline ::RoutingSubregion* RoutingPart::mutable_subregions(int index) { + return subregions_.Mutable(index); +} +inline ::RoutingSubregion* RoutingPart::add_subregions() { + return subregions_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::RoutingSubregion >& +RoutingPart::subregions() const { + return subregions_; +} +inline ::google::protobuf::RepeatedPtrField< ::RoutingSubregion >* +RoutingPart::mutable_subregions() { + return &subregions_; +} + +// ------------------------------------------------------------------- + +// TransportPart + +// required int64 size = 1; +inline bool TransportPart::has_size() const { + return _has_bit(0); +} +inline void TransportPart::clear_size() { + size_ = GOOGLE_LONGLONG(0); + _clear_bit(0); +} +inline ::google::protobuf::int64 TransportPart::size() const { + return size_; +} +inline void TransportPart::set_size(::google::protobuf::int64 value) { + _set_bit(0); + size_ = value; +} + +// required int64 offset = 2; +inline bool TransportPart::has_offset() const { + return _has_bit(1); +} +inline void TransportPart::clear_offset() { + offset_ = GOOGLE_LONGLONG(0); + _clear_bit(1); +} +inline ::google::protobuf::int64 TransportPart::offset() const { + return offset_; +} +inline void TransportPart::set_offset(::google::protobuf::int64 value) { + _set_bit(1); + offset_ = value; +} + +// optional string name = 3; +inline bool TransportPart::has_name() const { + return _has_bit(2); +} +inline void TransportPart::clear_name() { + if (name_ != &_default_name_) { + name_->clear(); + } + _clear_bit(2); +} +inline const ::std::string& TransportPart::name() const { + return *name_; +} +inline void TransportPart::set_name(const ::std::string& value) { + _set_bit(2); + if (name_ == &_default_name_) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void TransportPart::set_name(const char* value) { + _set_bit(2); + if (name_ == &_default_name_) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void TransportPart::set_name(const char* value, size_t size) { + _set_bit(2); + if (name_ == &_default_name_) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* TransportPart::mutable_name() { + _set_bit(2); + if (name_ == &_default_name_) { + name_ = new ::std::string; + } + return name_; +} + +// optional int32 left = 4; +inline bool TransportPart::has_left() const { + return _has_bit(3); +} +inline void TransportPart::clear_left() { + left_ = 0; + _clear_bit(3); +} +inline ::google::protobuf::int32 TransportPart::left() const { + return left_; +} +inline void TransportPart::set_left(::google::protobuf::int32 value) { + _set_bit(3); + left_ = value; +} + +// optional int32 right = 5; +inline bool TransportPart::has_right() const { + return _has_bit(4); +} +inline void TransportPart::clear_right() { + right_ = 0; + _clear_bit(4); +} +inline ::google::protobuf::int32 TransportPart::right() const { + return right_; +} +inline void TransportPart::set_right(::google::protobuf::int32 value) { + _set_bit(4); + right_ = value; +} + +// optional int32 top = 6; +inline bool TransportPart::has_top() const { + return _has_bit(5); +} +inline void TransportPart::clear_top() { + top_ = 0; + _clear_bit(5); +} +inline ::google::protobuf::int32 TransportPart::top() const { + return top_; +} +inline void TransportPart::set_top(::google::protobuf::int32 value) { + _set_bit(5); + top_ = value; +} + +// optional int32 bottom = 7; +inline bool TransportPart::has_bottom() const { + return _has_bit(6); +} +inline void TransportPart::clear_bottom() { + bottom_ = 0; + _clear_bit(6); +} +inline ::google::protobuf::int32 TransportPart::bottom() const { + return bottom_; +} +inline void TransportPart::set_bottom(::google::protobuf::int32 value) { + _set_bit(6); + bottom_ = value; +} + +// optional uint32 stringTableOffset = 8; +inline bool TransportPart::has_stringtableoffset() const { + return _has_bit(7); +} +inline void TransportPart::clear_stringtableoffset() { + stringtableoffset_ = 0u; + _clear_bit(7); +} +inline ::google::protobuf::uint32 TransportPart::stringtableoffset() const { + return stringtableoffset_; +} +inline void TransportPart::set_stringtableoffset(::google::protobuf::uint32 value) { + _set_bit(7); + stringtableoffset_ = value; +} + +// optional uint32 stringTableLength = 9; +inline bool TransportPart::has_stringtablelength() const { + return _has_bit(8); +} +inline void TransportPart::clear_stringtablelength() { + stringtablelength_ = 0u; + _clear_bit(8); +} +inline ::google::protobuf::uint32 TransportPart::stringtablelength() const { + return stringtablelength_; +} +inline void TransportPart::set_stringtablelength(::google::protobuf::uint32 value) { + _set_bit(8); + stringtablelength_ = value; +} + +// optional uint32 stopsTableOffset = 10; +inline bool TransportPart::has_stopstableoffset() const { + return _has_bit(9); +} +inline void TransportPart::clear_stopstableoffset() { + stopstableoffset_ = 0u; + _clear_bit(9); +} +inline ::google::protobuf::uint32 TransportPart::stopstableoffset() const { + return stopstableoffset_; +} +inline void TransportPart::set_stopstableoffset(::google::protobuf::uint32 value) { + _set_bit(9); + stopstableoffset_ = value; +} + +// optional uint32 stopsTableLength = 11; +inline bool TransportPart::has_stopstablelength() const { + return _has_bit(10); +} +inline void TransportPart::clear_stopstablelength() { + stopstablelength_ = 0u; + _clear_bit(10); +} +inline ::google::protobuf::uint32 TransportPart::stopstablelength() const { + return stopstablelength_; +} +inline void TransportPart::set_stopstablelength(::google::protobuf::uint32 value) { + _set_bit(10); + stopstablelength_ = value; +} + + +// @@protoc_insertion_point(namespace_scope) + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_osmand_5findex_2eproto__INCLUDED