From db74ea08f6e392ae496852a110bbed7e361f7a31 Mon Sep 17 00:00:00 2001 From: vng Date: Mon, 6 Feb 2012 17:27:09 +0300 Subject: [PATCH] [search] Use protobuf in lite mode for production configuration. --- 3party/protobuf/protobuf.pro | 18 + generator/generator_tool/generator_tool.cpp | 5 + indexer/classificator_loader.cpp | 8 +- indexer/drawing_rules.cpp | 13 +- indexer/drawing_rules.hpp | 6 +- indexer/drules_struct.proto | 2 +- indexer/drules_struct_lite.pb.cc | 2966 +++++++++++++++++++ indexer/drules_struct_lite.pb.h | 2233 ++++++++++++++ indexer/indexer.pro | 13 +- map/proto_to_yg_styles.cpp | 7 +- 10 files changed, 5257 insertions(+), 14 deletions(-) create mode 100644 indexer/drules_struct_lite.pb.cc create mode 100644 indexer/drules_struct_lite.pb.h diff --git a/3party/protobuf/protobuf.pro b/3party/protobuf/protobuf.pro index 3d5ba01238..3747e12796 100644 --- a/3party/protobuf/protobuf.pro +++ b/3party/protobuf/protobuf.pro @@ -21,6 +21,22 @@ unix|win32-g++ { QMAKE_CXXFLAGS_WARN_ON += -Wno-unused -Wno-extra } +CONFIG(production) { + +SOURCES += \ + src/google/protobuf/stubs/common.cc \ + src/google/protobuf/stubs/once.cc \ + src/google/protobuf/extension_set.cc \ + src/google/protobuf/generated_message_util.cc \ + src/google/protobuf/message_lite.cc \ + src/google/protobuf/repeated_field.cc \ + src/google/protobuf/wire_format_lite.cc \ + src/google/protobuf/io/coded_stream.cc \ + src/google/protobuf/io/zero_copy_stream.cc \ + src/google/protobuf/io/zero_copy_stream_impl_lite.cc \ + +} else { + SOURCES += \ src/google/protobuf/descriptor.cc \ src/google/protobuf/descriptor.pb.cc \ @@ -78,3 +94,5 @@ HEADERS += \ src/google/protobuf/stubs/stl_util-inl.h \ src/google/protobuf/stubs/strutil.h \ src/google/protobuf/stubs/substitute.h \ + +} diff --git a/generator/generator_tool/generator_tool.cpp b/generator/generator_tool/generator_tool.cpp index 53d7a2e376..62b4bc2730 100644 --- a/generator/generator_tool/generator_tool.cpp +++ b/generator/generator_tool/generator_tool.cpp @@ -34,7 +34,10 @@ DEFINE_bool(version, false, "Display version"); DEFINE_bool(generate_update, false, "If specified, update.maps file will be generated from cells in the data path"); +#ifndef OMIM_PRODUCTION DEFINE_bool(generate_classif, false, "Generate classificator."); +#endif + DEFINE_bool(preprocess_xml, false, "1st pass - create nodes/ways/relations data"); DEFINE_bool(make_coasts, false, "create intermediate file with coasts data"); DEFINE_bool(emit_coasts, false, "push coasts features from intermediate file to out files/countries"); @@ -93,6 +96,7 @@ int main(int argc, char ** argv) cout << "Built on: " << VERSION_DATE_STRING << endl; } +#ifndef OMIM_PRODUCTION // Make a classificator if (FLAGS_generate_classif) { @@ -106,6 +110,7 @@ int main(int argc, char ** argv) ofstream s((path + DRAWING_RULES_BIN_FILE).c_str(), ios::out | ios::binary); rules.SaveToBinaryProto(buffer, s); } +#endif // Generating intermediate files if (FLAGS_preprocess_xml) diff --git a/indexer/classificator_loader.cpp b/indexer/classificator_loader.cpp index 8056597f22..ba23a21e8e 100644 --- a/indexer/classificator_loader.cpp +++ b/indexer/classificator_loader.cpp @@ -68,10 +68,12 @@ namespace classificator #if defined(OMIM_PRODUCTION) || defined(USE_BINARY_STYLES) // Load from proto buffer binary file. - ReaderStreamBuf buffer(p.GetReader(DRAWING_RULES_BIN_FILE)); + ModelReaderPtr reader(p.GetReader(DRAWING_RULES_BIN_FILE)); - istream s(&buffer); - rules.LoadFromBinaryProto(s); + string buffer; + reader.ReadAsString(buffer); + + rules.LoadFromBinaryProto(buffer); #else // Load from proto buffer text file. string buffer; diff --git a/indexer/drawing_rules.cpp b/indexer/drawing_rules.cpp index f641353953..15d937f997 100644 --- a/indexer/drawing_rules.cpp +++ b/indexer/drawing_rules.cpp @@ -3,7 +3,12 @@ #include "drawing_rules.hpp" #include "scales.hpp" #include "classificator.hpp" -#include "drules_struct.pb.h" + +#ifdef OMIM_PRODUCTION + #include "drules_struct_lite.pb.h" +#else + #include "drules_struct.pb.h" +#endif #include "../std/bind.hpp" #include "../std/iterator_facade.hpp" @@ -360,6 +365,7 @@ namespace }; } +#ifndef OMIM_PRODUCTION void RulesHolder::LoadFromTextProto(string const & buffer) { Clean(); @@ -377,14 +383,15 @@ void RulesHolder::SaveToBinaryProto(string const & buffer, ostream & s) CHECK ( cont.SerializeToOstream(&s), ("Error in proto saving!") ); } +#endif -void RulesHolder::LoadFromBinaryProto(istream & s) +void RulesHolder::LoadFromBinaryProto(string const & s) { Clean(); DoSetIndex doSet(*this); - CHECK ( doSet.m_cont.ParseFromIstream(&s), ("Error in proto loading!") ); + CHECK ( doSet.m_cont.ParseFromString(s), ("Error in proto loading!") ); classif().GetMutableRoot()->ForEachObject(bind(ref(doSet), _1)); } diff --git a/indexer/drawing_rules.hpp b/indexer/drawing_rules.hpp index 7cd7724b6e..648e64542a 100644 --- a/indexer/drawing_rules.hpp +++ b/indexer/drawing_rules.hpp @@ -79,10 +79,12 @@ namespace drule BaseRule const * Find(Key const & k) const; +#ifndef OMIM_PRODUCTION void LoadFromTextProto(string const & buffer); - static void SaveToBinaryProto(string const & buffer, ostream & s); - void LoadFromBinaryProto(istream & s); +#endif + + void LoadFromBinaryProto(string const & s); template void ForEachRule(ToDo toDo) { diff --git a/indexer/drules_struct.proto b/indexer/drules_struct.proto index 53b22096b1..9edb326051 100644 --- a/indexer/drules_struct.proto +++ b/indexer/drules_struct.proto @@ -1,4 +1,4 @@ -// option optimize_for = LITE_RUNTIME; +option optimize_for = LITE_RUNTIME; message DashDotProto { diff --git a/indexer/drules_struct_lite.pb.cc b/indexer/drules_struct_lite.pb.cc new file mode 100644 index 0000000000..a8d8d91a31 --- /dev/null +++ b/indexer/drules_struct_lite.pb.cc @@ -0,0 +1,2966 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "drules_struct_lite.pb.h" + +#include + +#include +#include +#include +// @@protoc_insertion_point(includes) + +void protobuf_ShutdownFile_drules_5fstruct_2eproto() { + delete DashDotProto::default_instance_; + delete LineRuleProto::default_instance_; + delete LineDefProto::default_instance_; + delete AreaRuleProto::default_instance_; + delete SymbolRuleProto::default_instance_; + delete CaptionDefProto::default_instance_; + delete CaptionRuleProto::default_instance_; + delete CircleRuleProto::default_instance_; + delete PathTextRuleProto::default_instance_; + delete DrawElementProto::default_instance_; + delete ClassifElementProto::default_instance_; + delete ContainerProto::default_instance_; +} + +void protobuf_AddDesc_drules_5fstruct_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + DashDotProto::default_instance_ = new DashDotProto(); + LineRuleProto::default_instance_ = new LineRuleProto(); + LineDefProto::default_instance_ = new LineDefProto(); + AreaRuleProto::default_instance_ = new AreaRuleProto(); + SymbolRuleProto::default_instance_ = new SymbolRuleProto(); + CaptionDefProto::default_instance_ = new CaptionDefProto(); + CaptionRuleProto::default_instance_ = new CaptionRuleProto(); + CircleRuleProto::default_instance_ = new CircleRuleProto(); + PathTextRuleProto::default_instance_ = new PathTextRuleProto(); + DrawElementProto::default_instance_ = new DrawElementProto(); + ClassifElementProto::default_instance_ = new ClassifElementProto(); + ContainerProto::default_instance_ = new ContainerProto(); + DashDotProto::default_instance_->InitAsDefaultInstance(); + LineRuleProto::default_instance_->InitAsDefaultInstance(); + LineDefProto::default_instance_->InitAsDefaultInstance(); + AreaRuleProto::default_instance_->InitAsDefaultInstance(); + SymbolRuleProto::default_instance_->InitAsDefaultInstance(); + CaptionDefProto::default_instance_->InitAsDefaultInstance(); + CaptionRuleProto::default_instance_->InitAsDefaultInstance(); + CircleRuleProto::default_instance_->InitAsDefaultInstance(); + PathTextRuleProto::default_instance_->InitAsDefaultInstance(); + DrawElementProto::default_instance_->InitAsDefaultInstance(); + ClassifElementProto::default_instance_->InitAsDefaultInstance(); + ContainerProto::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_drules_5fstruct_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_drules_5fstruct_2eproto { + StaticDescriptorInitializer_drules_5fstruct_2eproto() { + protobuf_AddDesc_drules_5fstruct_2eproto(); + } +} static_descriptor_initializer_drules_5fstruct_2eproto_; + + +// =================================================================== + +#ifndef _MSC_VER +const int DashDotProto::kDdFieldNumber; +const int DashDotProto::kOffsetFieldNumber; +#endif // !_MSC_VER + +DashDotProto::DashDotProto() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void DashDotProto::InitAsDefaultInstance() { +} + +DashDotProto::DashDotProto(const DashDotProto& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void DashDotProto::SharedCtor() { + _cached_size_ = 0; + offset_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +DashDotProto::~DashDotProto() { + SharedDtor(); +} + +void DashDotProto::SharedDtor() { + if (this != default_instance_) { + } +} + +void DashDotProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const DashDotProto& DashDotProto::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto(); return *default_instance_; +} + +DashDotProto* DashDotProto::default_instance_ = NULL; + +DashDotProto* DashDotProto::New() const { + return new DashDotProto; +} + +void DashDotProto::Clear() { + if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) { + offset_ = 0; + } + dd_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool DashDotProto::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)) { + // repeated double dd = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_dd: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + 1, 9, input, this->mutable_dd()))); + } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) + == ::google::protobuf::internal::WireFormatLite:: + WIRETYPE_LENGTH_DELIMITED) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + input, this->mutable_dd()))); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(9)) goto parse_dd; + if (input->ExpectTag(17)) goto parse_offset; + break; + } + + // optional double offset = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_offset: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + input, &offset_))); + set_has_offset(); + } 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 DashDotProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // repeated double dd = 1; + for (int i = 0; i < this->dd_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteDouble( + 1, this->dd(i), output); + } + + // optional double offset = 2; + if (has_offset()) { + ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->offset(), output); + } + +} + +int DashDotProto::ByteSize() const { + int total_size = 0; + + if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) { + // optional double offset = 2; + if (has_offset()) { + total_size += 1 + 8; + } + + } + // repeated double dd = 1; + { + int data_size = 0; + data_size = 8 * this->dd_size(); + total_size += 1 * this->dd_size() + data_size; + } + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void DashDotProto::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void DashDotProto::MergeFrom(const DashDotProto& from) { + GOOGLE_CHECK_NE(&from, this); + dd_.MergeFrom(from.dd_); + if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) { + if (from.has_offset()) { + set_offset(from.offset()); + } + } +} + +void DashDotProto::CopyFrom(const DashDotProto& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DashDotProto::IsInitialized() const { + + return true; +} + +void DashDotProto::Swap(DashDotProto* other) { + if (other != this) { + dd_.Swap(&other->dd_); + std::swap(offset_, other->offset_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string DashDotProto::GetTypeName() const { + return "DashDotProto"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int LineRuleProto::kWidthFieldNumber; +const int LineRuleProto::kColorFieldNumber; +const int LineRuleProto::kDashdotFieldNumber; +const int LineRuleProto::kPriorityFieldNumber; +#endif // !_MSC_VER + +LineRuleProto::LineRuleProto() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void LineRuleProto::InitAsDefaultInstance() { + dashdot_ = const_cast< ::DashDotProto*>(&::DashDotProto::default_instance()); +} + +LineRuleProto::LineRuleProto(const LineRuleProto& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void LineRuleProto::SharedCtor() { + _cached_size_ = 0; + width_ = 0; + color_ = 0u; + dashdot_ = NULL; + priority_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +LineRuleProto::~LineRuleProto() { + SharedDtor(); +} + +void LineRuleProto::SharedDtor() { + if (this != default_instance_) { + delete dashdot_; + } +} + +void LineRuleProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const LineRuleProto& LineRuleProto::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto(); return *default_instance_; +} + +LineRuleProto* LineRuleProto::default_instance_ = NULL; + +LineRuleProto* LineRuleProto::New() const { + return new LineRuleProto; +} + +void LineRuleProto::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + width_ = 0; + color_ = 0u; + if (has_dashdot()) { + if (dashdot_ != NULL) dashdot_->::DashDotProto::Clear(); + } + priority_ = 0; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool LineRuleProto::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 double width = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + input, &width_))); + set_has_width(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_color; + break; + } + + // required uint32 color = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_color: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &color_))); + set_has_color(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_dashdot; + break; + } + + // optional .DashDotProto dashdot = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_dashdot: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_dashdot())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(32)) goto parse_priority; + break; + } + + // required int32 priority = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_priority: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &priority_))); + set_has_priority(); + } 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 LineRuleProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required double width = 1; + if (has_width()) { + ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->width(), output); + } + + // required uint32 color = 2; + if (has_color()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->color(), output); + } + + // optional .DashDotProto dashdot = 3; + if (has_dashdot()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 3, this->dashdot(), output); + } + + // required int32 priority = 4; + if (has_priority()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->priority(), output); + } + +} + +int LineRuleProto::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required double width = 1; + if (has_width()) { + total_size += 1 + 8; + } + + // required uint32 color = 2; + if (has_color()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->color()); + } + + // optional .DashDotProto dashdot = 3; + if (has_dashdot()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->dashdot()); + } + + // required int32 priority = 4; + if (has_priority()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->priority()); + } + + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void LineRuleProto::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void LineRuleProto::MergeFrom(const LineRuleProto& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_width()) { + set_width(from.width()); + } + if (from.has_color()) { + set_color(from.color()); + } + if (from.has_dashdot()) { + mutable_dashdot()->::DashDotProto::MergeFrom(from.dashdot()); + } + if (from.has_priority()) { + set_priority(from.priority()); + } + } +} + +void LineRuleProto::CopyFrom(const LineRuleProto& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool LineRuleProto::IsInitialized() const { + if ((_has_bits_[0] & 0x0000000b) != 0x0000000b) return false; + + return true; +} + +void LineRuleProto::Swap(LineRuleProto* other) { + if (other != this) { + std::swap(width_, other->width_); + std::swap(color_, other->color_); + std::swap(dashdot_, other->dashdot_); + std::swap(priority_, other->priority_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string LineRuleProto::GetTypeName() const { + return "LineRuleProto"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int LineDefProto::kWidthFieldNumber; +const int LineDefProto::kColorFieldNumber; +const int LineDefProto::kDashdotFieldNumber; +#endif // !_MSC_VER + +LineDefProto::LineDefProto() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void LineDefProto::InitAsDefaultInstance() { + dashdot_ = const_cast< ::DashDotProto*>(&::DashDotProto::default_instance()); +} + +LineDefProto::LineDefProto(const LineDefProto& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void LineDefProto::SharedCtor() { + _cached_size_ = 0; + width_ = 0; + color_ = 0u; + dashdot_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +LineDefProto::~LineDefProto() { + SharedDtor(); +} + +void LineDefProto::SharedDtor() { + if (this != default_instance_) { + delete dashdot_; + } +} + +void LineDefProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const LineDefProto& LineDefProto::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto(); return *default_instance_; +} + +LineDefProto* LineDefProto::default_instance_ = NULL; + +LineDefProto* LineDefProto::New() const { + return new LineDefProto; +} + +void LineDefProto::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + width_ = 0; + color_ = 0u; + if (has_dashdot()) { + if (dashdot_ != NULL) dashdot_->::DashDotProto::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool LineDefProto::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 double width = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + input, &width_))); + set_has_width(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_color; + break; + } + + // required uint32 color = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_color: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &color_))); + set_has_color(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_dashdot; + break; + } + + // optional .DashDotProto dashdot = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_dashdot: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_dashdot())); + } 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 LineDefProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required double width = 1; + if (has_width()) { + ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->width(), output); + } + + // required uint32 color = 2; + if (has_color()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->color(), output); + } + + // optional .DashDotProto dashdot = 3; + if (has_dashdot()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 3, this->dashdot(), output); + } + +} + +int LineDefProto::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required double width = 1; + if (has_width()) { + total_size += 1 + 8; + } + + // required uint32 color = 2; + if (has_color()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->color()); + } + + // optional .DashDotProto dashdot = 3; + if (has_dashdot()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->dashdot()); + } + + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void LineDefProto::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void LineDefProto::MergeFrom(const LineDefProto& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_width()) { + set_width(from.width()); + } + if (from.has_color()) { + set_color(from.color()); + } + if (from.has_dashdot()) { + mutable_dashdot()->::DashDotProto::MergeFrom(from.dashdot()); + } + } +} + +void LineDefProto::CopyFrom(const LineDefProto& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool LineDefProto::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void LineDefProto::Swap(LineDefProto* other) { + if (other != this) { + std::swap(width_, other->width_); + std::swap(color_, other->color_); + std::swap(dashdot_, other->dashdot_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string LineDefProto::GetTypeName() const { + return "LineDefProto"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AreaRuleProto::kColorFieldNumber; +const int AreaRuleProto::kBorderFieldNumber; +const int AreaRuleProto::kPriorityFieldNumber; +#endif // !_MSC_VER + +AreaRuleProto::AreaRuleProto() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void AreaRuleProto::InitAsDefaultInstance() { + border_ = const_cast< ::LineDefProto*>(&::LineDefProto::default_instance()); +} + +AreaRuleProto::AreaRuleProto(const AreaRuleProto& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void AreaRuleProto::SharedCtor() { + _cached_size_ = 0; + color_ = 0u; + border_ = NULL; + priority_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AreaRuleProto::~AreaRuleProto() { + SharedDtor(); +} + +void AreaRuleProto::SharedDtor() { + if (this != default_instance_) { + delete border_; + } +} + +void AreaRuleProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const AreaRuleProto& AreaRuleProto::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto(); return *default_instance_; +} + +AreaRuleProto* AreaRuleProto::default_instance_ = NULL; + +AreaRuleProto* AreaRuleProto::New() const { + return new AreaRuleProto; +} + +void AreaRuleProto::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + color_ = 0u; + if (has_border()) { + if (border_ != NULL) border_->::LineDefProto::Clear(); + } + priority_ = 0; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool AreaRuleProto::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 color = 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, &color_))); + set_has_color(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_border; + break; + } + + // optional .LineDefProto border = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_border: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_border())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(24)) goto parse_priority; + break; + } + + // required int32 priority = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_priority: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &priority_))); + set_has_priority(); + } 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 AreaRuleProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required uint32 color = 1; + if (has_color()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->color(), output); + } + + // optional .LineDefProto border = 2; + if (has_border()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 2, this->border(), output); + } + + // required int32 priority = 3; + if (has_priority()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->priority(), output); + } + +} + +int AreaRuleProto::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required uint32 color = 1; + if (has_color()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->color()); + } + + // optional .LineDefProto border = 2; + if (has_border()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->border()); + } + + // required int32 priority = 3; + if (has_priority()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->priority()); + } + + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void AreaRuleProto::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void AreaRuleProto::MergeFrom(const AreaRuleProto& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_color()) { + set_color(from.color()); + } + if (from.has_border()) { + mutable_border()->::LineDefProto::MergeFrom(from.border()); + } + if (from.has_priority()) { + set_priority(from.priority()); + } + } +} + +void AreaRuleProto::CopyFrom(const AreaRuleProto& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AreaRuleProto::IsInitialized() const { + if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false; + + if (has_border()) { + if (!this->border().IsInitialized()) return false; + } + return true; +} + +void AreaRuleProto::Swap(AreaRuleProto* other) { + if (other != this) { + std::swap(color_, other->color_); + std::swap(border_, other->border_); + std::swap(priority_, other->priority_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string AreaRuleProto::GetTypeName() const { + return "AreaRuleProto"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int SymbolRuleProto::kNameFieldNumber; +const int SymbolRuleProto::kApplyForTypeFieldNumber; +const int SymbolRuleProto::kPriorityFieldNumber; +#endif // !_MSC_VER + +SymbolRuleProto::SymbolRuleProto() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void SymbolRuleProto::InitAsDefaultInstance() { +} + +SymbolRuleProto::SymbolRuleProto(const SymbolRuleProto& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void SymbolRuleProto::SharedCtor() { + _cached_size_ = 0; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + apply_for_type_ = 0; + priority_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +SymbolRuleProto::~SymbolRuleProto() { + SharedDtor(); +} + +void SymbolRuleProto::SharedDtor() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (this != default_instance_) { + } +} + +void SymbolRuleProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const SymbolRuleProto& SymbolRuleProto::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto(); return *default_instance_; +} + +SymbolRuleProto* SymbolRuleProto::default_instance_ = NULL; + +SymbolRuleProto* SymbolRuleProto::New() const { + return new SymbolRuleProto; +} + +void SymbolRuleProto::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_name()) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + } + apply_for_type_ = 0; + priority_ = 0; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool SymbolRuleProto::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 string name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_apply_for_type; + break; + } + + // optional int32 apply_for_type = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_apply_for_type: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &apply_for_type_))); + set_has_apply_for_type(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(24)) goto parse_priority; + break; + } + + // required int32 priority = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_priority: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &priority_))); + set_has_priority(); + } 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 SymbolRuleProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string name = 1; + if (has_name()) { + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->name(), output); + } + + // optional int32 apply_for_type = 2; + if (has_apply_for_type()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->apply_for_type(), output); + } + + // required int32 priority = 3; + if (has_priority()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->priority(), output); + } + +} + +int SymbolRuleProto::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string name = 1; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // optional int32 apply_for_type = 2; + if (has_apply_for_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->apply_for_type()); + } + + // required int32 priority = 3; + if (has_priority()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->priority()); + } + + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void SymbolRuleProto::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void SymbolRuleProto::MergeFrom(const SymbolRuleProto& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_name()) { + set_name(from.name()); + } + if (from.has_apply_for_type()) { + set_apply_for_type(from.apply_for_type()); + } + if (from.has_priority()) { + set_priority(from.priority()); + } + } +} + +void SymbolRuleProto::CopyFrom(const SymbolRuleProto& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SymbolRuleProto::IsInitialized() const { + if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false; + + return true; +} + +void SymbolRuleProto::Swap(SymbolRuleProto* other) { + if (other != this) { + std::swap(name_, other->name_); + std::swap(apply_for_type_, other->apply_for_type_); + std::swap(priority_, other->priority_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string SymbolRuleProto::GetTypeName() const { + return "SymbolRuleProto"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int CaptionDefProto::kHeightFieldNumber; +const int CaptionDefProto::kColorFieldNumber; +const int CaptionDefProto::kStrokeColorFieldNumber; +#endif // !_MSC_VER + +CaptionDefProto::CaptionDefProto() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void CaptionDefProto::InitAsDefaultInstance() { +} + +CaptionDefProto::CaptionDefProto(const CaptionDefProto& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void CaptionDefProto::SharedCtor() { + _cached_size_ = 0; + height_ = 0; + color_ = 0u; + stroke_color_ = 0u; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CaptionDefProto::~CaptionDefProto() { + SharedDtor(); +} + +void CaptionDefProto::SharedDtor() { + if (this != default_instance_) { + } +} + +void CaptionDefProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const CaptionDefProto& CaptionDefProto::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto(); return *default_instance_; +} + +CaptionDefProto* CaptionDefProto::default_instance_ = NULL; + +CaptionDefProto* CaptionDefProto::New() const { + return new CaptionDefProto; +} + +void CaptionDefProto::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + height_ = 0; + color_ = 0u; + stroke_color_ = 0u; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool CaptionDefProto::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 int32 height = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &height_))); + set_has_height(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_color; + break; + } + + // required uint32 color = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_color: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &color_))); + set_has_color(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(24)) goto parse_stroke_color; + break; + } + + // optional uint32 stroke_color = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_stroke_color: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &stroke_color_))); + set_has_stroke_color(); + } 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 CaptionDefProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required int32 height = 1; + if (has_height()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->height(), output); + } + + // required uint32 color = 2; + if (has_color()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->color(), output); + } + + // optional uint32 stroke_color = 3; + if (has_stroke_color()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->stroke_color(), output); + } + +} + +int CaptionDefProto::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required int32 height = 1; + if (has_height()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->height()); + } + + // required uint32 color = 2; + if (has_color()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->color()); + } + + // optional uint32 stroke_color = 3; + if (has_stroke_color()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->stroke_color()); + } + + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void CaptionDefProto::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void CaptionDefProto::MergeFrom(const CaptionDefProto& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_height()) { + set_height(from.height()); + } + if (from.has_color()) { + set_color(from.color()); + } + if (from.has_stroke_color()) { + set_stroke_color(from.stroke_color()); + } + } +} + +void CaptionDefProto::CopyFrom(const CaptionDefProto& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CaptionDefProto::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void CaptionDefProto::Swap(CaptionDefProto* other) { + if (other != this) { + std::swap(height_, other->height_); + std::swap(color_, other->color_); + std::swap(stroke_color_, other->stroke_color_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string CaptionDefProto::GetTypeName() const { + return "CaptionDefProto"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int CaptionRuleProto::kPrimaryFieldNumber; +const int CaptionRuleProto::kSecondaryFieldNumber; +const int CaptionRuleProto::kPriorityFieldNumber; +#endif // !_MSC_VER + +CaptionRuleProto::CaptionRuleProto() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void CaptionRuleProto::InitAsDefaultInstance() { + primary_ = const_cast< ::CaptionDefProto*>(&::CaptionDefProto::default_instance()); + secondary_ = const_cast< ::CaptionDefProto*>(&::CaptionDefProto::default_instance()); +} + +CaptionRuleProto::CaptionRuleProto(const CaptionRuleProto& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void CaptionRuleProto::SharedCtor() { + _cached_size_ = 0; + primary_ = NULL; + secondary_ = NULL; + priority_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CaptionRuleProto::~CaptionRuleProto() { + SharedDtor(); +} + +void CaptionRuleProto::SharedDtor() { + if (this != default_instance_) { + delete primary_; + delete secondary_; + } +} + +void CaptionRuleProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const CaptionRuleProto& CaptionRuleProto::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto(); return *default_instance_; +} + +CaptionRuleProto* CaptionRuleProto::default_instance_ = NULL; + +CaptionRuleProto* CaptionRuleProto::New() const { + return new CaptionRuleProto; +} + +void CaptionRuleProto::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_primary()) { + if (primary_ != NULL) primary_->::CaptionDefProto::Clear(); + } + if (has_secondary()) { + if (secondary_ != NULL) secondary_->::CaptionDefProto::Clear(); + } + priority_ = 0; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool CaptionRuleProto::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 .CaptionDefProto primary = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_primary())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_secondary; + break; + } + + // optional .CaptionDefProto secondary = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_secondary: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_secondary())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(24)) goto parse_priority; + break; + } + + // required int32 priority = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_priority: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &priority_))); + set_has_priority(); + } 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 CaptionRuleProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .CaptionDefProto primary = 1; + if (has_primary()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 1, this->primary(), output); + } + + // optional .CaptionDefProto secondary = 2; + if (has_secondary()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 2, this->secondary(), output); + } + + // required int32 priority = 3; + if (has_priority()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->priority(), output); + } + +} + +int CaptionRuleProto::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .CaptionDefProto primary = 1; + if (has_primary()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->primary()); + } + + // optional .CaptionDefProto secondary = 2; + if (has_secondary()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->secondary()); + } + + // required int32 priority = 3; + if (has_priority()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->priority()); + } + + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void CaptionRuleProto::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void CaptionRuleProto::MergeFrom(const CaptionRuleProto& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_primary()) { + mutable_primary()->::CaptionDefProto::MergeFrom(from.primary()); + } + if (from.has_secondary()) { + mutable_secondary()->::CaptionDefProto::MergeFrom(from.secondary()); + } + if (from.has_priority()) { + set_priority(from.priority()); + } + } +} + +void CaptionRuleProto::CopyFrom(const CaptionRuleProto& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CaptionRuleProto::IsInitialized() const { + if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false; + + if (has_primary()) { + if (!this->primary().IsInitialized()) return false; + } + if (has_secondary()) { + if (!this->secondary().IsInitialized()) return false; + } + return true; +} + +void CaptionRuleProto::Swap(CaptionRuleProto* other) { + if (other != this) { + std::swap(primary_, other->primary_); + std::swap(secondary_, other->secondary_); + std::swap(priority_, other->priority_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string CaptionRuleProto::GetTypeName() const { + return "CaptionRuleProto"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int CircleRuleProto::kRadiusFieldNumber; +const int CircleRuleProto::kColorFieldNumber; +const int CircleRuleProto::kBorderFieldNumber; +const int CircleRuleProto::kPriorityFieldNumber; +#endif // !_MSC_VER + +CircleRuleProto::CircleRuleProto() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void CircleRuleProto::InitAsDefaultInstance() { + border_ = const_cast< ::LineDefProto*>(&::LineDefProto::default_instance()); +} + +CircleRuleProto::CircleRuleProto(const CircleRuleProto& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void CircleRuleProto::SharedCtor() { + _cached_size_ = 0; + radius_ = 0; + color_ = 0u; + border_ = NULL; + priority_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CircleRuleProto::~CircleRuleProto() { + SharedDtor(); +} + +void CircleRuleProto::SharedDtor() { + if (this != default_instance_) { + delete border_; + } +} + +void CircleRuleProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const CircleRuleProto& CircleRuleProto::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto(); return *default_instance_; +} + +CircleRuleProto* CircleRuleProto::default_instance_ = NULL; + +CircleRuleProto* CircleRuleProto::New() const { + return new CircleRuleProto; +} + +void CircleRuleProto::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + radius_ = 0; + color_ = 0u; + if (has_border()) { + if (border_ != NULL) border_->::LineDefProto::Clear(); + } + priority_ = 0; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool CircleRuleProto::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 double radius = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + input, &radius_))); + set_has_radius(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_color; + break; + } + + // required uint32 color = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_color: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &color_))); + set_has_color(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_border; + break; + } + + // optional .LineDefProto border = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_border: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_border())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(32)) goto parse_priority; + break; + } + + // required int32 priority = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_priority: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &priority_))); + set_has_priority(); + } 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 CircleRuleProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required double radius = 1; + if (has_radius()) { + ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->radius(), output); + } + + // required uint32 color = 2; + if (has_color()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->color(), output); + } + + // optional .LineDefProto border = 3; + if (has_border()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 3, this->border(), output); + } + + // required int32 priority = 4; + if (has_priority()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->priority(), output); + } + +} + +int CircleRuleProto::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required double radius = 1; + if (has_radius()) { + total_size += 1 + 8; + } + + // required uint32 color = 2; + if (has_color()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->color()); + } + + // optional .LineDefProto border = 3; + if (has_border()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->border()); + } + + // required int32 priority = 4; + if (has_priority()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->priority()); + } + + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void CircleRuleProto::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void CircleRuleProto::MergeFrom(const CircleRuleProto& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_radius()) { + set_radius(from.radius()); + } + if (from.has_color()) { + set_color(from.color()); + } + if (from.has_border()) { + mutable_border()->::LineDefProto::MergeFrom(from.border()); + } + if (from.has_priority()) { + set_priority(from.priority()); + } + } +} + +void CircleRuleProto::CopyFrom(const CircleRuleProto& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CircleRuleProto::IsInitialized() const { + if ((_has_bits_[0] & 0x0000000b) != 0x0000000b) return false; + + if (has_border()) { + if (!this->border().IsInitialized()) return false; + } + return true; +} + +void CircleRuleProto::Swap(CircleRuleProto* other) { + if (other != this) { + std::swap(radius_, other->radius_); + std::swap(color_, other->color_); + std::swap(border_, other->border_); + std::swap(priority_, other->priority_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string CircleRuleProto::GetTypeName() const { + return "CircleRuleProto"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int PathTextRuleProto::kPrimaryFieldNumber; +const int PathTextRuleProto::kSecondaryFieldNumber; +const int PathTextRuleProto::kPriorityFieldNumber; +#endif // !_MSC_VER + +PathTextRuleProto::PathTextRuleProto() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void PathTextRuleProto::InitAsDefaultInstance() { + primary_ = const_cast< ::CaptionDefProto*>(&::CaptionDefProto::default_instance()); + secondary_ = const_cast< ::CaptionDefProto*>(&::CaptionDefProto::default_instance()); +} + +PathTextRuleProto::PathTextRuleProto(const PathTextRuleProto& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void PathTextRuleProto::SharedCtor() { + _cached_size_ = 0; + primary_ = NULL; + secondary_ = NULL; + priority_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +PathTextRuleProto::~PathTextRuleProto() { + SharedDtor(); +} + +void PathTextRuleProto::SharedDtor() { + if (this != default_instance_) { + delete primary_; + delete secondary_; + } +} + +void PathTextRuleProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const PathTextRuleProto& PathTextRuleProto::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto(); return *default_instance_; +} + +PathTextRuleProto* PathTextRuleProto::default_instance_ = NULL; + +PathTextRuleProto* PathTextRuleProto::New() const { + return new PathTextRuleProto; +} + +void PathTextRuleProto::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_primary()) { + if (primary_ != NULL) primary_->::CaptionDefProto::Clear(); + } + if (has_secondary()) { + if (secondary_ != NULL) secondary_->::CaptionDefProto::Clear(); + } + priority_ = 0; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool PathTextRuleProto::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 .CaptionDefProto primary = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_primary())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_secondary; + break; + } + + // optional .CaptionDefProto secondary = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_secondary: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_secondary())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(24)) goto parse_priority; + break; + } + + // required int32 priority = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_priority: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &priority_))); + set_has_priority(); + } 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 PathTextRuleProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .CaptionDefProto primary = 1; + if (has_primary()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 1, this->primary(), output); + } + + // optional .CaptionDefProto secondary = 2; + if (has_secondary()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 2, this->secondary(), output); + } + + // required int32 priority = 3; + if (has_priority()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->priority(), output); + } + +} + +int PathTextRuleProto::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .CaptionDefProto primary = 1; + if (has_primary()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->primary()); + } + + // optional .CaptionDefProto secondary = 2; + if (has_secondary()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->secondary()); + } + + // required int32 priority = 3; + if (has_priority()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->priority()); + } + + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void PathTextRuleProto::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void PathTextRuleProto::MergeFrom(const PathTextRuleProto& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_primary()) { + mutable_primary()->::CaptionDefProto::MergeFrom(from.primary()); + } + if (from.has_secondary()) { + mutable_secondary()->::CaptionDefProto::MergeFrom(from.secondary()); + } + if (from.has_priority()) { + set_priority(from.priority()); + } + } +} + +void PathTextRuleProto::CopyFrom(const PathTextRuleProto& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PathTextRuleProto::IsInitialized() const { + if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false; + + if (has_primary()) { + if (!this->primary().IsInitialized()) return false; + } + if (has_secondary()) { + if (!this->secondary().IsInitialized()) return false; + } + return true; +} + +void PathTextRuleProto::Swap(PathTextRuleProto* other) { + if (other != this) { + std::swap(primary_, other->primary_); + std::swap(secondary_, other->secondary_); + std::swap(priority_, other->priority_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string PathTextRuleProto::GetTypeName() const { + return "PathTextRuleProto"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int DrawElementProto::kScaleFieldNumber; +const int DrawElementProto::kLinesFieldNumber; +const int DrawElementProto::kAreaFieldNumber; +const int DrawElementProto::kSymbolFieldNumber; +const int DrawElementProto::kCaptionFieldNumber; +const int DrawElementProto::kCircleFieldNumber; +const int DrawElementProto::kPathTextFieldNumber; +#endif // !_MSC_VER + +DrawElementProto::DrawElementProto() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void DrawElementProto::InitAsDefaultInstance() { + area_ = const_cast< ::AreaRuleProto*>(&::AreaRuleProto::default_instance()); + symbol_ = const_cast< ::SymbolRuleProto*>(&::SymbolRuleProto::default_instance()); + caption_ = const_cast< ::CaptionRuleProto*>(&::CaptionRuleProto::default_instance()); + circle_ = const_cast< ::CircleRuleProto*>(&::CircleRuleProto::default_instance()); + path_text_ = const_cast< ::PathTextRuleProto*>(&::PathTextRuleProto::default_instance()); +} + +DrawElementProto::DrawElementProto(const DrawElementProto& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void DrawElementProto::SharedCtor() { + _cached_size_ = 0; + scale_ = 0; + area_ = NULL; + symbol_ = NULL; + caption_ = NULL; + circle_ = NULL; + path_text_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +DrawElementProto::~DrawElementProto() { + SharedDtor(); +} + +void DrawElementProto::SharedDtor() { + if (this != default_instance_) { + delete area_; + delete symbol_; + delete caption_; + delete circle_; + delete path_text_; + } +} + +void DrawElementProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const DrawElementProto& DrawElementProto::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto(); return *default_instance_; +} + +DrawElementProto* DrawElementProto::default_instance_ = NULL; + +DrawElementProto* DrawElementProto::New() const { + return new DrawElementProto; +} + +void DrawElementProto::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + scale_ = 0; + if (has_area()) { + if (area_ != NULL) area_->::AreaRuleProto::Clear(); + } + if (has_symbol()) { + if (symbol_ != NULL) symbol_->::SymbolRuleProto::Clear(); + } + if (has_caption()) { + if (caption_ != NULL) caption_->::CaptionRuleProto::Clear(); + } + if (has_circle()) { + if (circle_ != NULL) circle_->::CircleRuleProto::Clear(); + } + if (has_path_text()) { + if (path_text_ != NULL) path_text_->::PathTextRuleProto::Clear(); + } + } + lines_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool DrawElementProto::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 int32 scale = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &scale_))); + set_has_scale(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_lines; + break; + } + + // repeated .LineRuleProto lines = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_lines: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_lines())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_lines; + if (input->ExpectTag(26)) goto parse_area; + break; + } + + // optional .AreaRuleProto area = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_area: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_area())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(34)) goto parse_symbol; + break; + } + + // optional .SymbolRuleProto symbol = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_symbol: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_symbol())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(42)) goto parse_caption; + break; + } + + // optional .CaptionRuleProto caption = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_caption: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_caption())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(50)) goto parse_circle; + break; + } + + // optional .CircleRuleProto circle = 6; + case 6: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_circle: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_circle())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(58)) goto parse_path_text; + break; + } + + // optional .PathTextRuleProto path_text = 7; + case 7: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_path_text: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_path_text())); + } 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 DrawElementProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required int32 scale = 1; + if (has_scale()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->scale(), output); + } + + // repeated .LineRuleProto lines = 2; + for (int i = 0; i < this->lines_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 2, this->lines(i), output); + } + + // optional .AreaRuleProto area = 3; + if (has_area()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 3, this->area(), output); + } + + // optional .SymbolRuleProto symbol = 4; + if (has_symbol()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 4, this->symbol(), output); + } + + // optional .CaptionRuleProto caption = 5; + if (has_caption()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 5, this->caption(), output); + } + + // optional .CircleRuleProto circle = 6; + if (has_circle()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 6, this->circle(), output); + } + + // optional .PathTextRuleProto path_text = 7; + if (has_path_text()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 7, this->path_text(), output); + } + +} + +int DrawElementProto::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required int32 scale = 1; + if (has_scale()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->scale()); + } + + // optional .AreaRuleProto area = 3; + if (has_area()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->area()); + } + + // optional .SymbolRuleProto symbol = 4; + if (has_symbol()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->symbol()); + } + + // optional .CaptionRuleProto caption = 5; + if (has_caption()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->caption()); + } + + // optional .CircleRuleProto circle = 6; + if (has_circle()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->circle()); + } + + // optional .PathTextRuleProto path_text = 7; + if (has_path_text()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->path_text()); + } + + } + // repeated .LineRuleProto lines = 2; + total_size += 1 * this->lines_size(); + for (int i = 0; i < this->lines_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->lines(i)); + } + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void DrawElementProto::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void DrawElementProto::MergeFrom(const DrawElementProto& from) { + GOOGLE_CHECK_NE(&from, this); + lines_.MergeFrom(from.lines_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_scale()) { + set_scale(from.scale()); + } + if (from.has_area()) { + mutable_area()->::AreaRuleProto::MergeFrom(from.area()); + } + if (from.has_symbol()) { + mutable_symbol()->::SymbolRuleProto::MergeFrom(from.symbol()); + } + if (from.has_caption()) { + mutable_caption()->::CaptionRuleProto::MergeFrom(from.caption()); + } + if (from.has_circle()) { + mutable_circle()->::CircleRuleProto::MergeFrom(from.circle()); + } + if (from.has_path_text()) { + mutable_path_text()->::PathTextRuleProto::MergeFrom(from.path_text()); + } + } +} + +void DrawElementProto::CopyFrom(const DrawElementProto& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DrawElementProto::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + for (int i = 0; i < lines_size(); i++) { + if (!this->lines(i).IsInitialized()) return false; + } + if (has_area()) { + if (!this->area().IsInitialized()) return false; + } + if (has_symbol()) { + if (!this->symbol().IsInitialized()) return false; + } + if (has_caption()) { + if (!this->caption().IsInitialized()) return false; + } + if (has_circle()) { + if (!this->circle().IsInitialized()) return false; + } + if (has_path_text()) { + if (!this->path_text().IsInitialized()) return false; + } + return true; +} + +void DrawElementProto::Swap(DrawElementProto* other) { + if (other != this) { + std::swap(scale_, other->scale_); + lines_.Swap(&other->lines_); + std::swap(area_, other->area_); + std::swap(symbol_, other->symbol_); + std::swap(caption_, other->caption_); + std::swap(circle_, other->circle_); + std::swap(path_text_, other->path_text_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string DrawElementProto::GetTypeName() const { + return "DrawElementProto"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ClassifElementProto::kNameFieldNumber; +const int ClassifElementProto::kElementFieldNumber; +#endif // !_MSC_VER + +ClassifElementProto::ClassifElementProto() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void ClassifElementProto::InitAsDefaultInstance() { +} + +ClassifElementProto::ClassifElementProto(const ClassifElementProto& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void ClassifElementProto::SharedCtor() { + _cached_size_ = 0; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ClassifElementProto::~ClassifElementProto() { + SharedDtor(); +} + +void ClassifElementProto::SharedDtor() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (this != default_instance_) { + } +} + +void ClassifElementProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ClassifElementProto& ClassifElementProto::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto(); return *default_instance_; +} + +ClassifElementProto* ClassifElementProto::default_instance_ = NULL; + +ClassifElementProto* ClassifElementProto::New() const { + return new ClassifElementProto; +} + +void ClassifElementProto::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_name()) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + } + } + element_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool ClassifElementProto::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 string name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_element; + break; + } + + // repeated .DrawElementProto element = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_element: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_element())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_element; + 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 ClassifElementProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string name = 1; + if (has_name()) { + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->name(), output); + } + + // repeated .DrawElementProto element = 2; + for (int i = 0; i < this->element_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 2, this->element(i), output); + } + +} + +int ClassifElementProto::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string name = 1; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + } + // repeated .DrawElementProto element = 2; + total_size += 1 * this->element_size(); + for (int i = 0; i < this->element_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->element(i)); + } + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ClassifElementProto::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void ClassifElementProto::MergeFrom(const ClassifElementProto& from) { + GOOGLE_CHECK_NE(&from, this); + element_.MergeFrom(from.element_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_name()) { + set_name(from.name()); + } + } +} + +void ClassifElementProto::CopyFrom(const ClassifElementProto& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ClassifElementProto::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + for (int i = 0; i < element_size(); i++) { + if (!this->element(i).IsInitialized()) return false; + } + return true; +} + +void ClassifElementProto::Swap(ClassifElementProto* other) { + if (other != this) { + std::swap(name_, other->name_); + element_.Swap(&other->element_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string ClassifElementProto::GetTypeName() const { + return "ClassifElementProto"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ContainerProto::kContFieldNumber; +#endif // !_MSC_VER + +ContainerProto::ContainerProto() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void ContainerProto::InitAsDefaultInstance() { +} + +ContainerProto::ContainerProto(const ContainerProto& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void ContainerProto::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ContainerProto::~ContainerProto() { + SharedDtor(); +} + +void ContainerProto::SharedDtor() { + if (this != default_instance_) { + } +} + +void ContainerProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ContainerProto& ContainerProto::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto(); return *default_instance_; +} + +ContainerProto* ContainerProto::default_instance_ = NULL; + +ContainerProto* ContainerProto::New() const { + return new ContainerProto; +} + +void ContainerProto::Clear() { + cont_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool ContainerProto::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)) { + // repeated .ClassifElementProto cont = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_cont: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_cont())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(10)) goto parse_cont; + 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 ContainerProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // repeated .ClassifElementProto cont = 1; + for (int i = 0; i < this->cont_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 1, this->cont(i), output); + } + +} + +int ContainerProto::ByteSize() const { + int total_size = 0; + + // repeated .ClassifElementProto cont = 1; + total_size += 1 * this->cont_size(); + for (int i = 0; i < this->cont_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->cont(i)); + } + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ContainerProto::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void ContainerProto::MergeFrom(const ContainerProto& from) { + GOOGLE_CHECK_NE(&from, this); + cont_.MergeFrom(from.cont_); +} + +void ContainerProto::CopyFrom(const ContainerProto& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ContainerProto::IsInitialized() const { + + for (int i = 0; i < cont_size(); i++) { + if (!this->cont(i).IsInitialized()) return false; + } + return true; +} + +void ContainerProto::Swap(ContainerProto* other) { + if (other != this) { + cont_.Swap(&other->cont_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string ContainerProto::GetTypeName() const { + return "ContainerProto"; +} + + +// @@protoc_insertion_point(namespace_scope) + +// @@protoc_insertion_point(global_scope) diff --git a/indexer/drules_struct_lite.pb.h b/indexer/drules_struct_lite.pb.h new file mode 100644 index 0000000000..38b11b5d7c --- /dev/null +++ b/indexer/drules_struct_lite.pb.h @@ -0,0 +1,2233 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: drules_struct.proto + +#ifndef PROTOBUF_drules_5fstruct_2eproto__INCLUDED +#define PROTOBUF_drules_5fstruct_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2004000 +#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 2004001 < 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_drules_5fstruct_2eproto(); +void protobuf_AssignDesc_drules_5fstruct_2eproto(); +void protobuf_ShutdownFile_drules_5fstruct_2eproto(); + +class DashDotProto; +class LineRuleProto; +class LineDefProto; +class AreaRuleProto; +class SymbolRuleProto; +class CaptionDefProto; +class CaptionRuleProto; +class CircleRuleProto; +class PathTextRuleProto; +class DrawElementProto; +class ClassifElementProto; +class ContainerProto; + +// =================================================================== + +class DashDotProto : public ::google::protobuf::MessageLite { + public: + DashDotProto(); + virtual ~DashDotProto(); + + DashDotProto(const DashDotProto& from); + + inline DashDotProto& operator=(const DashDotProto& from) { + CopyFrom(from); + return *this; + } + + static const DashDotProto& default_instance(); + + void Swap(DashDotProto* other); + + // implements Message ---------------------------------------------- + + DashDotProto* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const DashDotProto& from); + void MergeFrom(const DashDotProto& 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 ------------------------------------------------------- + + // repeated double dd = 1; + inline int dd_size() const; + inline void clear_dd(); + static const int kDdFieldNumber = 1; + inline double dd(int index) const; + inline void set_dd(int index, double value); + inline void add_dd(double value); + inline const ::google::protobuf::RepeatedField< double >& + dd() const; + inline ::google::protobuf::RepeatedField< double >* + mutable_dd(); + + // optional double offset = 2; + inline bool has_offset() const; + inline void clear_offset(); + static const int kOffsetFieldNumber = 2; + inline double offset() const; + inline void set_offset(double value); + + // @@protoc_insertion_point(class_scope:DashDotProto) + private: + inline void set_has_offset(); + inline void clear_has_offset(); + + ::google::protobuf::RepeatedField< double > dd_; + double offset_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_drules_5fstruct_2eproto(); + friend void protobuf_AssignDesc_drules_5fstruct_2eproto(); + friend void protobuf_ShutdownFile_drules_5fstruct_2eproto(); + + void InitAsDefaultInstance(); + static DashDotProto* default_instance_; +}; +// ------------------------------------------------------------------- + +class LineRuleProto : public ::google::protobuf::MessageLite { + public: + LineRuleProto(); + virtual ~LineRuleProto(); + + LineRuleProto(const LineRuleProto& from); + + inline LineRuleProto& operator=(const LineRuleProto& from) { + CopyFrom(from); + return *this; + } + + static const LineRuleProto& default_instance(); + + void Swap(LineRuleProto* other); + + // implements Message ---------------------------------------------- + + LineRuleProto* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const LineRuleProto& from); + void MergeFrom(const LineRuleProto& 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 double width = 1; + inline bool has_width() const; + inline void clear_width(); + static const int kWidthFieldNumber = 1; + inline double width() const; + inline void set_width(double value); + + // required uint32 color = 2; + inline bool has_color() const; + inline void clear_color(); + static const int kColorFieldNumber = 2; + inline ::google::protobuf::uint32 color() const; + inline void set_color(::google::protobuf::uint32 value); + + // optional .DashDotProto dashdot = 3; + inline bool has_dashdot() const; + inline void clear_dashdot(); + static const int kDashdotFieldNumber = 3; + inline const ::DashDotProto& dashdot() const; + inline ::DashDotProto* mutable_dashdot(); + inline ::DashDotProto* release_dashdot(); + + // required int32 priority = 4; + inline bool has_priority() const; + inline void clear_priority(); + static const int kPriorityFieldNumber = 4; + inline ::google::protobuf::int32 priority() const; + inline void set_priority(::google::protobuf::int32 value); + + // @@protoc_insertion_point(class_scope:LineRuleProto) + private: + inline void set_has_width(); + inline void clear_has_width(); + inline void set_has_color(); + inline void clear_has_color(); + inline void set_has_dashdot(); + inline void clear_has_dashdot(); + inline void set_has_priority(); + inline void clear_has_priority(); + + double width_; + ::DashDotProto* dashdot_; + ::google::protobuf::uint32 color_; + ::google::protobuf::int32 priority_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; + + friend void protobuf_AddDesc_drules_5fstruct_2eproto(); + friend void protobuf_AssignDesc_drules_5fstruct_2eproto(); + friend void protobuf_ShutdownFile_drules_5fstruct_2eproto(); + + void InitAsDefaultInstance(); + static LineRuleProto* default_instance_; +}; +// ------------------------------------------------------------------- + +class LineDefProto : public ::google::protobuf::MessageLite { + public: + LineDefProto(); + virtual ~LineDefProto(); + + LineDefProto(const LineDefProto& from); + + inline LineDefProto& operator=(const LineDefProto& from) { + CopyFrom(from); + return *this; + } + + static const LineDefProto& default_instance(); + + void Swap(LineDefProto* other); + + // implements Message ---------------------------------------------- + + LineDefProto* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const LineDefProto& from); + void MergeFrom(const LineDefProto& 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 double width = 1; + inline bool has_width() const; + inline void clear_width(); + static const int kWidthFieldNumber = 1; + inline double width() const; + inline void set_width(double value); + + // required uint32 color = 2; + inline bool has_color() const; + inline void clear_color(); + static const int kColorFieldNumber = 2; + inline ::google::protobuf::uint32 color() const; + inline void set_color(::google::protobuf::uint32 value); + + // optional .DashDotProto dashdot = 3; + inline bool has_dashdot() const; + inline void clear_dashdot(); + static const int kDashdotFieldNumber = 3; + inline const ::DashDotProto& dashdot() const; + inline ::DashDotProto* mutable_dashdot(); + inline ::DashDotProto* release_dashdot(); + + // @@protoc_insertion_point(class_scope:LineDefProto) + private: + inline void set_has_width(); + inline void clear_has_width(); + inline void set_has_color(); + inline void clear_has_color(); + inline void set_has_dashdot(); + inline void clear_has_dashdot(); + + double width_; + ::DashDotProto* dashdot_; + ::google::protobuf::uint32 color_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_drules_5fstruct_2eproto(); + friend void protobuf_AssignDesc_drules_5fstruct_2eproto(); + friend void protobuf_ShutdownFile_drules_5fstruct_2eproto(); + + void InitAsDefaultInstance(); + static LineDefProto* default_instance_; +}; +// ------------------------------------------------------------------- + +class AreaRuleProto : public ::google::protobuf::MessageLite { + public: + AreaRuleProto(); + virtual ~AreaRuleProto(); + + AreaRuleProto(const AreaRuleProto& from); + + inline AreaRuleProto& operator=(const AreaRuleProto& from) { + CopyFrom(from); + return *this; + } + + static const AreaRuleProto& default_instance(); + + void Swap(AreaRuleProto* other); + + // implements Message ---------------------------------------------- + + AreaRuleProto* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const AreaRuleProto& from); + void MergeFrom(const AreaRuleProto& 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 color = 1; + inline bool has_color() const; + inline void clear_color(); + static const int kColorFieldNumber = 1; + inline ::google::protobuf::uint32 color() const; + inline void set_color(::google::protobuf::uint32 value); + + // optional .LineDefProto border = 2; + inline bool has_border() const; + inline void clear_border(); + static const int kBorderFieldNumber = 2; + inline const ::LineDefProto& border() const; + inline ::LineDefProto* mutable_border(); + inline ::LineDefProto* release_border(); + + // required int32 priority = 3; + inline bool has_priority() const; + inline void clear_priority(); + static const int kPriorityFieldNumber = 3; + inline ::google::protobuf::int32 priority() const; + inline void set_priority(::google::protobuf::int32 value); + + // @@protoc_insertion_point(class_scope:AreaRuleProto) + private: + inline void set_has_color(); + inline void clear_has_color(); + inline void set_has_border(); + inline void clear_has_border(); + inline void set_has_priority(); + inline void clear_has_priority(); + + ::LineDefProto* border_; + ::google::protobuf::uint32 color_; + ::google::protobuf::int32 priority_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_drules_5fstruct_2eproto(); + friend void protobuf_AssignDesc_drules_5fstruct_2eproto(); + friend void protobuf_ShutdownFile_drules_5fstruct_2eproto(); + + void InitAsDefaultInstance(); + static AreaRuleProto* default_instance_; +}; +// ------------------------------------------------------------------- + +class SymbolRuleProto : public ::google::protobuf::MessageLite { + public: + SymbolRuleProto(); + virtual ~SymbolRuleProto(); + + SymbolRuleProto(const SymbolRuleProto& from); + + inline SymbolRuleProto& operator=(const SymbolRuleProto& from) { + CopyFrom(from); + return *this; + } + + static const SymbolRuleProto& default_instance(); + + void Swap(SymbolRuleProto* other); + + // implements Message ---------------------------------------------- + + SymbolRuleProto* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const SymbolRuleProto& from); + void MergeFrom(const SymbolRuleProto& 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 string name = 1; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 1; + 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(); + inline ::std::string* release_name(); + + // optional int32 apply_for_type = 2; + inline bool has_apply_for_type() const; + inline void clear_apply_for_type(); + static const int kApplyForTypeFieldNumber = 2; + inline ::google::protobuf::int32 apply_for_type() const; + inline void set_apply_for_type(::google::protobuf::int32 value); + + // required int32 priority = 3; + inline bool has_priority() const; + inline void clear_priority(); + static const int kPriorityFieldNumber = 3; + inline ::google::protobuf::int32 priority() const; + inline void set_priority(::google::protobuf::int32 value); + + // @@protoc_insertion_point(class_scope:SymbolRuleProto) + private: + inline void set_has_name(); + inline void clear_has_name(); + inline void set_has_apply_for_type(); + inline void clear_has_apply_for_type(); + inline void set_has_priority(); + inline void clear_has_priority(); + + ::std::string* name_; + ::google::protobuf::int32 apply_for_type_; + ::google::protobuf::int32 priority_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_drules_5fstruct_2eproto(); + friend void protobuf_AssignDesc_drules_5fstruct_2eproto(); + friend void protobuf_ShutdownFile_drules_5fstruct_2eproto(); + + void InitAsDefaultInstance(); + static SymbolRuleProto* default_instance_; +}; +// ------------------------------------------------------------------- + +class CaptionDefProto : public ::google::protobuf::MessageLite { + public: + CaptionDefProto(); + virtual ~CaptionDefProto(); + + CaptionDefProto(const CaptionDefProto& from); + + inline CaptionDefProto& operator=(const CaptionDefProto& from) { + CopyFrom(from); + return *this; + } + + static const CaptionDefProto& default_instance(); + + void Swap(CaptionDefProto* other); + + // implements Message ---------------------------------------------- + + CaptionDefProto* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const CaptionDefProto& from); + void MergeFrom(const CaptionDefProto& 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 int32 height = 1; + inline bool has_height() const; + inline void clear_height(); + static const int kHeightFieldNumber = 1; + inline ::google::protobuf::int32 height() const; + inline void set_height(::google::protobuf::int32 value); + + // required uint32 color = 2; + inline bool has_color() const; + inline void clear_color(); + static const int kColorFieldNumber = 2; + inline ::google::protobuf::uint32 color() const; + inline void set_color(::google::protobuf::uint32 value); + + // optional uint32 stroke_color = 3; + inline bool has_stroke_color() const; + inline void clear_stroke_color(); + static const int kStrokeColorFieldNumber = 3; + inline ::google::protobuf::uint32 stroke_color() const; + inline void set_stroke_color(::google::protobuf::uint32 value); + + // @@protoc_insertion_point(class_scope:CaptionDefProto) + private: + inline void set_has_height(); + inline void clear_has_height(); + inline void set_has_color(); + inline void clear_has_color(); + inline void set_has_stroke_color(); + inline void clear_has_stroke_color(); + + ::google::protobuf::int32 height_; + ::google::protobuf::uint32 color_; + ::google::protobuf::uint32 stroke_color_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_drules_5fstruct_2eproto(); + friend void protobuf_AssignDesc_drules_5fstruct_2eproto(); + friend void protobuf_ShutdownFile_drules_5fstruct_2eproto(); + + void InitAsDefaultInstance(); + static CaptionDefProto* default_instance_; +}; +// ------------------------------------------------------------------- + +class CaptionRuleProto : public ::google::protobuf::MessageLite { + public: + CaptionRuleProto(); + virtual ~CaptionRuleProto(); + + CaptionRuleProto(const CaptionRuleProto& from); + + inline CaptionRuleProto& operator=(const CaptionRuleProto& from) { + CopyFrom(from); + return *this; + } + + static const CaptionRuleProto& default_instance(); + + void Swap(CaptionRuleProto* other); + + // implements Message ---------------------------------------------- + + CaptionRuleProto* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const CaptionRuleProto& from); + void MergeFrom(const CaptionRuleProto& 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 .CaptionDefProto primary = 1; + inline bool has_primary() const; + inline void clear_primary(); + static const int kPrimaryFieldNumber = 1; + inline const ::CaptionDefProto& primary() const; + inline ::CaptionDefProto* mutable_primary(); + inline ::CaptionDefProto* release_primary(); + + // optional .CaptionDefProto secondary = 2; + inline bool has_secondary() const; + inline void clear_secondary(); + static const int kSecondaryFieldNumber = 2; + inline const ::CaptionDefProto& secondary() const; + inline ::CaptionDefProto* mutable_secondary(); + inline ::CaptionDefProto* release_secondary(); + + // required int32 priority = 3; + inline bool has_priority() const; + inline void clear_priority(); + static const int kPriorityFieldNumber = 3; + inline ::google::protobuf::int32 priority() const; + inline void set_priority(::google::protobuf::int32 value); + + // @@protoc_insertion_point(class_scope:CaptionRuleProto) + private: + inline void set_has_primary(); + inline void clear_has_primary(); + inline void set_has_secondary(); + inline void clear_has_secondary(); + inline void set_has_priority(); + inline void clear_has_priority(); + + ::CaptionDefProto* primary_; + ::CaptionDefProto* secondary_; + ::google::protobuf::int32 priority_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_drules_5fstruct_2eproto(); + friend void protobuf_AssignDesc_drules_5fstruct_2eproto(); + friend void protobuf_ShutdownFile_drules_5fstruct_2eproto(); + + void InitAsDefaultInstance(); + static CaptionRuleProto* default_instance_; +}; +// ------------------------------------------------------------------- + +class CircleRuleProto : public ::google::protobuf::MessageLite { + public: + CircleRuleProto(); + virtual ~CircleRuleProto(); + + CircleRuleProto(const CircleRuleProto& from); + + inline CircleRuleProto& operator=(const CircleRuleProto& from) { + CopyFrom(from); + return *this; + } + + static const CircleRuleProto& default_instance(); + + void Swap(CircleRuleProto* other); + + // implements Message ---------------------------------------------- + + CircleRuleProto* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const CircleRuleProto& from); + void MergeFrom(const CircleRuleProto& 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 double radius = 1; + inline bool has_radius() const; + inline void clear_radius(); + static const int kRadiusFieldNumber = 1; + inline double radius() const; + inline void set_radius(double value); + + // required uint32 color = 2; + inline bool has_color() const; + inline void clear_color(); + static const int kColorFieldNumber = 2; + inline ::google::protobuf::uint32 color() const; + inline void set_color(::google::protobuf::uint32 value); + + // optional .LineDefProto border = 3; + inline bool has_border() const; + inline void clear_border(); + static const int kBorderFieldNumber = 3; + inline const ::LineDefProto& border() const; + inline ::LineDefProto* mutable_border(); + inline ::LineDefProto* release_border(); + + // required int32 priority = 4; + inline bool has_priority() const; + inline void clear_priority(); + static const int kPriorityFieldNumber = 4; + inline ::google::protobuf::int32 priority() const; + inline void set_priority(::google::protobuf::int32 value); + + // @@protoc_insertion_point(class_scope:CircleRuleProto) + private: + inline void set_has_radius(); + inline void clear_has_radius(); + inline void set_has_color(); + inline void clear_has_color(); + inline void set_has_border(); + inline void clear_has_border(); + inline void set_has_priority(); + inline void clear_has_priority(); + + double radius_; + ::LineDefProto* border_; + ::google::protobuf::uint32 color_; + ::google::protobuf::int32 priority_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; + + friend void protobuf_AddDesc_drules_5fstruct_2eproto(); + friend void protobuf_AssignDesc_drules_5fstruct_2eproto(); + friend void protobuf_ShutdownFile_drules_5fstruct_2eproto(); + + void InitAsDefaultInstance(); + static CircleRuleProto* default_instance_; +}; +// ------------------------------------------------------------------- + +class PathTextRuleProto : public ::google::protobuf::MessageLite { + public: + PathTextRuleProto(); + virtual ~PathTextRuleProto(); + + PathTextRuleProto(const PathTextRuleProto& from); + + inline PathTextRuleProto& operator=(const PathTextRuleProto& from) { + CopyFrom(from); + return *this; + } + + static const PathTextRuleProto& default_instance(); + + void Swap(PathTextRuleProto* other); + + // implements Message ---------------------------------------------- + + PathTextRuleProto* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const PathTextRuleProto& from); + void MergeFrom(const PathTextRuleProto& 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 .CaptionDefProto primary = 1; + inline bool has_primary() const; + inline void clear_primary(); + static const int kPrimaryFieldNumber = 1; + inline const ::CaptionDefProto& primary() const; + inline ::CaptionDefProto* mutable_primary(); + inline ::CaptionDefProto* release_primary(); + + // optional .CaptionDefProto secondary = 2; + inline bool has_secondary() const; + inline void clear_secondary(); + static const int kSecondaryFieldNumber = 2; + inline const ::CaptionDefProto& secondary() const; + inline ::CaptionDefProto* mutable_secondary(); + inline ::CaptionDefProto* release_secondary(); + + // required int32 priority = 3; + inline bool has_priority() const; + inline void clear_priority(); + static const int kPriorityFieldNumber = 3; + inline ::google::protobuf::int32 priority() const; + inline void set_priority(::google::protobuf::int32 value); + + // @@protoc_insertion_point(class_scope:PathTextRuleProto) + private: + inline void set_has_primary(); + inline void clear_has_primary(); + inline void set_has_secondary(); + inline void clear_has_secondary(); + inline void set_has_priority(); + inline void clear_has_priority(); + + ::CaptionDefProto* primary_; + ::CaptionDefProto* secondary_; + ::google::protobuf::int32 priority_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_drules_5fstruct_2eproto(); + friend void protobuf_AssignDesc_drules_5fstruct_2eproto(); + friend void protobuf_ShutdownFile_drules_5fstruct_2eproto(); + + void InitAsDefaultInstance(); + static PathTextRuleProto* default_instance_; +}; +// ------------------------------------------------------------------- + +class DrawElementProto : public ::google::protobuf::MessageLite { + public: + DrawElementProto(); + virtual ~DrawElementProto(); + + DrawElementProto(const DrawElementProto& from); + + inline DrawElementProto& operator=(const DrawElementProto& from) { + CopyFrom(from); + return *this; + } + + static const DrawElementProto& default_instance(); + + void Swap(DrawElementProto* other); + + // implements Message ---------------------------------------------- + + DrawElementProto* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const DrawElementProto& from); + void MergeFrom(const DrawElementProto& 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 int32 scale = 1; + inline bool has_scale() const; + inline void clear_scale(); + static const int kScaleFieldNumber = 1; + inline ::google::protobuf::int32 scale() const; + inline void set_scale(::google::protobuf::int32 value); + + // repeated .LineRuleProto lines = 2; + inline int lines_size() const; + inline void clear_lines(); + static const int kLinesFieldNumber = 2; + inline const ::LineRuleProto& lines(int index) const; + inline ::LineRuleProto* mutable_lines(int index); + inline ::LineRuleProto* add_lines(); + inline const ::google::protobuf::RepeatedPtrField< ::LineRuleProto >& + lines() const; + inline ::google::protobuf::RepeatedPtrField< ::LineRuleProto >* + mutable_lines(); + + // optional .AreaRuleProto area = 3; + inline bool has_area() const; + inline void clear_area(); + static const int kAreaFieldNumber = 3; + inline const ::AreaRuleProto& area() const; + inline ::AreaRuleProto* mutable_area(); + inline ::AreaRuleProto* release_area(); + + // optional .SymbolRuleProto symbol = 4; + inline bool has_symbol() const; + inline void clear_symbol(); + static const int kSymbolFieldNumber = 4; + inline const ::SymbolRuleProto& symbol() const; + inline ::SymbolRuleProto* mutable_symbol(); + inline ::SymbolRuleProto* release_symbol(); + + // optional .CaptionRuleProto caption = 5; + inline bool has_caption() const; + inline void clear_caption(); + static const int kCaptionFieldNumber = 5; + inline const ::CaptionRuleProto& caption() const; + inline ::CaptionRuleProto* mutable_caption(); + inline ::CaptionRuleProto* release_caption(); + + // optional .CircleRuleProto circle = 6; + inline bool has_circle() const; + inline void clear_circle(); + static const int kCircleFieldNumber = 6; + inline const ::CircleRuleProto& circle() const; + inline ::CircleRuleProto* mutable_circle(); + inline ::CircleRuleProto* release_circle(); + + // optional .PathTextRuleProto path_text = 7; + inline bool has_path_text() const; + inline void clear_path_text(); + static const int kPathTextFieldNumber = 7; + inline const ::PathTextRuleProto& path_text() const; + inline ::PathTextRuleProto* mutable_path_text(); + inline ::PathTextRuleProto* release_path_text(); + + // @@protoc_insertion_point(class_scope:DrawElementProto) + private: + inline void set_has_scale(); + inline void clear_has_scale(); + inline void set_has_area(); + inline void clear_has_area(); + inline void set_has_symbol(); + inline void clear_has_symbol(); + inline void set_has_caption(); + inline void clear_has_caption(); + inline void set_has_circle(); + inline void clear_has_circle(); + inline void set_has_path_text(); + inline void clear_has_path_text(); + + ::google::protobuf::RepeatedPtrField< ::LineRuleProto > lines_; + ::AreaRuleProto* area_; + ::SymbolRuleProto* symbol_; + ::CaptionRuleProto* caption_; + ::CircleRuleProto* circle_; + ::PathTextRuleProto* path_text_; + ::google::protobuf::int32 scale_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32]; + + friend void protobuf_AddDesc_drules_5fstruct_2eproto(); + friend void protobuf_AssignDesc_drules_5fstruct_2eproto(); + friend void protobuf_ShutdownFile_drules_5fstruct_2eproto(); + + void InitAsDefaultInstance(); + static DrawElementProto* default_instance_; +}; +// ------------------------------------------------------------------- + +class ClassifElementProto : public ::google::protobuf::MessageLite { + public: + ClassifElementProto(); + virtual ~ClassifElementProto(); + + ClassifElementProto(const ClassifElementProto& from); + + inline ClassifElementProto& operator=(const ClassifElementProto& from) { + CopyFrom(from); + return *this; + } + + static const ClassifElementProto& default_instance(); + + void Swap(ClassifElementProto* other); + + // implements Message ---------------------------------------------- + + ClassifElementProto* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const ClassifElementProto& from); + void MergeFrom(const ClassifElementProto& 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 string name = 1; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 1; + 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(); + inline ::std::string* release_name(); + + // repeated .DrawElementProto element = 2; + inline int element_size() const; + inline void clear_element(); + static const int kElementFieldNumber = 2; + inline const ::DrawElementProto& element(int index) const; + inline ::DrawElementProto* mutable_element(int index); + inline ::DrawElementProto* add_element(); + inline const ::google::protobuf::RepeatedPtrField< ::DrawElementProto >& + element() const; + inline ::google::protobuf::RepeatedPtrField< ::DrawElementProto >* + mutable_element(); + + // @@protoc_insertion_point(class_scope:ClassifElementProto) + private: + inline void set_has_name(); + inline void clear_has_name(); + + ::std::string* name_; + ::google::protobuf::RepeatedPtrField< ::DrawElementProto > element_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_drules_5fstruct_2eproto(); + friend void protobuf_AssignDesc_drules_5fstruct_2eproto(); + friend void protobuf_ShutdownFile_drules_5fstruct_2eproto(); + + void InitAsDefaultInstance(); + static ClassifElementProto* default_instance_; +}; +// ------------------------------------------------------------------- + +class ContainerProto : public ::google::protobuf::MessageLite { + public: + ContainerProto(); + virtual ~ContainerProto(); + + ContainerProto(const ContainerProto& from); + + inline ContainerProto& operator=(const ContainerProto& from) { + CopyFrom(from); + return *this; + } + + static const ContainerProto& default_instance(); + + void Swap(ContainerProto* other); + + // implements Message ---------------------------------------------- + + ContainerProto* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const ContainerProto& from); + void MergeFrom(const ContainerProto& 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 ------------------------------------------------------- + + // repeated .ClassifElementProto cont = 1; + inline int cont_size() const; + inline void clear_cont(); + static const int kContFieldNumber = 1; + inline const ::ClassifElementProto& cont(int index) const; + inline ::ClassifElementProto* mutable_cont(int index); + inline ::ClassifElementProto* add_cont(); + inline const ::google::protobuf::RepeatedPtrField< ::ClassifElementProto >& + cont() const; + inline ::google::protobuf::RepeatedPtrField< ::ClassifElementProto >* + mutable_cont(); + + // @@protoc_insertion_point(class_scope:ContainerProto) + private: + + ::google::protobuf::RepeatedPtrField< ::ClassifElementProto > cont_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_drules_5fstruct_2eproto(); + friend void protobuf_AssignDesc_drules_5fstruct_2eproto(); + friend void protobuf_ShutdownFile_drules_5fstruct_2eproto(); + + void InitAsDefaultInstance(); + static ContainerProto* default_instance_; +}; +// =================================================================== + + +// =================================================================== + +// DashDotProto + +// repeated double dd = 1; +inline int DashDotProto::dd_size() const { + return dd_.size(); +} +inline void DashDotProto::clear_dd() { + dd_.Clear(); +} +inline double DashDotProto::dd(int index) const { + return dd_.Get(index); +} +inline void DashDotProto::set_dd(int index, double value) { + dd_.Set(index, value); +} +inline void DashDotProto::add_dd(double value) { + dd_.Add(value); +} +inline const ::google::protobuf::RepeatedField< double >& +DashDotProto::dd() const { + return dd_; +} +inline ::google::protobuf::RepeatedField< double >* +DashDotProto::mutable_dd() { + return &dd_; +} + +// optional double offset = 2; +inline bool DashDotProto::has_offset() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void DashDotProto::set_has_offset() { + _has_bits_[0] |= 0x00000002u; +} +inline void DashDotProto::clear_has_offset() { + _has_bits_[0] &= ~0x00000002u; +} +inline void DashDotProto::clear_offset() { + offset_ = 0; + clear_has_offset(); +} +inline double DashDotProto::offset() const { + return offset_; +} +inline void DashDotProto::set_offset(double value) { + set_has_offset(); + offset_ = value; +} + +// ------------------------------------------------------------------- + +// LineRuleProto + +// required double width = 1; +inline bool LineRuleProto::has_width() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void LineRuleProto::set_has_width() { + _has_bits_[0] |= 0x00000001u; +} +inline void LineRuleProto::clear_has_width() { + _has_bits_[0] &= ~0x00000001u; +} +inline void LineRuleProto::clear_width() { + width_ = 0; + clear_has_width(); +} +inline double LineRuleProto::width() const { + return width_; +} +inline void LineRuleProto::set_width(double value) { + set_has_width(); + width_ = value; +} + +// required uint32 color = 2; +inline bool LineRuleProto::has_color() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void LineRuleProto::set_has_color() { + _has_bits_[0] |= 0x00000002u; +} +inline void LineRuleProto::clear_has_color() { + _has_bits_[0] &= ~0x00000002u; +} +inline void LineRuleProto::clear_color() { + color_ = 0u; + clear_has_color(); +} +inline ::google::protobuf::uint32 LineRuleProto::color() const { + return color_; +} +inline void LineRuleProto::set_color(::google::protobuf::uint32 value) { + set_has_color(); + color_ = value; +} + +// optional .DashDotProto dashdot = 3; +inline bool LineRuleProto::has_dashdot() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void LineRuleProto::set_has_dashdot() { + _has_bits_[0] |= 0x00000004u; +} +inline void LineRuleProto::clear_has_dashdot() { + _has_bits_[0] &= ~0x00000004u; +} +inline void LineRuleProto::clear_dashdot() { + if (dashdot_ != NULL) dashdot_->::DashDotProto::Clear(); + clear_has_dashdot(); +} +inline const ::DashDotProto& LineRuleProto::dashdot() const { + return dashdot_ != NULL ? *dashdot_ : *default_instance_->dashdot_; +} +inline ::DashDotProto* LineRuleProto::mutable_dashdot() { + set_has_dashdot(); + if (dashdot_ == NULL) dashdot_ = new ::DashDotProto; + return dashdot_; +} +inline ::DashDotProto* LineRuleProto::release_dashdot() { + clear_has_dashdot(); + ::DashDotProto* temp = dashdot_; + dashdot_ = NULL; + return temp; +} + +// required int32 priority = 4; +inline bool LineRuleProto::has_priority() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void LineRuleProto::set_has_priority() { + _has_bits_[0] |= 0x00000008u; +} +inline void LineRuleProto::clear_has_priority() { + _has_bits_[0] &= ~0x00000008u; +} +inline void LineRuleProto::clear_priority() { + priority_ = 0; + clear_has_priority(); +} +inline ::google::protobuf::int32 LineRuleProto::priority() const { + return priority_; +} +inline void LineRuleProto::set_priority(::google::protobuf::int32 value) { + set_has_priority(); + priority_ = value; +} + +// ------------------------------------------------------------------- + +// LineDefProto + +// required double width = 1; +inline bool LineDefProto::has_width() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void LineDefProto::set_has_width() { + _has_bits_[0] |= 0x00000001u; +} +inline void LineDefProto::clear_has_width() { + _has_bits_[0] &= ~0x00000001u; +} +inline void LineDefProto::clear_width() { + width_ = 0; + clear_has_width(); +} +inline double LineDefProto::width() const { + return width_; +} +inline void LineDefProto::set_width(double value) { + set_has_width(); + width_ = value; +} + +// required uint32 color = 2; +inline bool LineDefProto::has_color() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void LineDefProto::set_has_color() { + _has_bits_[0] |= 0x00000002u; +} +inline void LineDefProto::clear_has_color() { + _has_bits_[0] &= ~0x00000002u; +} +inline void LineDefProto::clear_color() { + color_ = 0u; + clear_has_color(); +} +inline ::google::protobuf::uint32 LineDefProto::color() const { + return color_; +} +inline void LineDefProto::set_color(::google::protobuf::uint32 value) { + set_has_color(); + color_ = value; +} + +// optional .DashDotProto dashdot = 3; +inline bool LineDefProto::has_dashdot() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void LineDefProto::set_has_dashdot() { + _has_bits_[0] |= 0x00000004u; +} +inline void LineDefProto::clear_has_dashdot() { + _has_bits_[0] &= ~0x00000004u; +} +inline void LineDefProto::clear_dashdot() { + if (dashdot_ != NULL) dashdot_->::DashDotProto::Clear(); + clear_has_dashdot(); +} +inline const ::DashDotProto& LineDefProto::dashdot() const { + return dashdot_ != NULL ? *dashdot_ : *default_instance_->dashdot_; +} +inline ::DashDotProto* LineDefProto::mutable_dashdot() { + set_has_dashdot(); + if (dashdot_ == NULL) dashdot_ = new ::DashDotProto; + return dashdot_; +} +inline ::DashDotProto* LineDefProto::release_dashdot() { + clear_has_dashdot(); + ::DashDotProto* temp = dashdot_; + dashdot_ = NULL; + return temp; +} + +// ------------------------------------------------------------------- + +// AreaRuleProto + +// required uint32 color = 1; +inline bool AreaRuleProto::has_color() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void AreaRuleProto::set_has_color() { + _has_bits_[0] |= 0x00000001u; +} +inline void AreaRuleProto::clear_has_color() { + _has_bits_[0] &= ~0x00000001u; +} +inline void AreaRuleProto::clear_color() { + color_ = 0u; + clear_has_color(); +} +inline ::google::protobuf::uint32 AreaRuleProto::color() const { + return color_; +} +inline void AreaRuleProto::set_color(::google::protobuf::uint32 value) { + set_has_color(); + color_ = value; +} + +// optional .LineDefProto border = 2; +inline bool AreaRuleProto::has_border() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void AreaRuleProto::set_has_border() { + _has_bits_[0] |= 0x00000002u; +} +inline void AreaRuleProto::clear_has_border() { + _has_bits_[0] &= ~0x00000002u; +} +inline void AreaRuleProto::clear_border() { + if (border_ != NULL) border_->::LineDefProto::Clear(); + clear_has_border(); +} +inline const ::LineDefProto& AreaRuleProto::border() const { + return border_ != NULL ? *border_ : *default_instance_->border_; +} +inline ::LineDefProto* AreaRuleProto::mutable_border() { + set_has_border(); + if (border_ == NULL) border_ = new ::LineDefProto; + return border_; +} +inline ::LineDefProto* AreaRuleProto::release_border() { + clear_has_border(); + ::LineDefProto* temp = border_; + border_ = NULL; + return temp; +} + +// required int32 priority = 3; +inline bool AreaRuleProto::has_priority() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void AreaRuleProto::set_has_priority() { + _has_bits_[0] |= 0x00000004u; +} +inline void AreaRuleProto::clear_has_priority() { + _has_bits_[0] &= ~0x00000004u; +} +inline void AreaRuleProto::clear_priority() { + priority_ = 0; + clear_has_priority(); +} +inline ::google::protobuf::int32 AreaRuleProto::priority() const { + return priority_; +} +inline void AreaRuleProto::set_priority(::google::protobuf::int32 value) { + set_has_priority(); + priority_ = value; +} + +// ------------------------------------------------------------------- + +// SymbolRuleProto + +// required string name = 1; +inline bool SymbolRuleProto::has_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void SymbolRuleProto::set_has_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void SymbolRuleProto::clear_has_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void SymbolRuleProto::clear_name() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + clear_has_name(); +} +inline const ::std::string& SymbolRuleProto::name() const { + return *name_; +} +inline void SymbolRuleProto::set_name(const ::std::string& value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void SymbolRuleProto::set_name(const char* value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void SymbolRuleProto::set_name(const char* value, size_t size) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* SymbolRuleProto::mutable_name() { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + return name_; +} +inline ::std::string* SymbolRuleProto::release_name() { + clear_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = name_; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} + +// optional int32 apply_for_type = 2; +inline bool SymbolRuleProto::has_apply_for_type() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void SymbolRuleProto::set_has_apply_for_type() { + _has_bits_[0] |= 0x00000002u; +} +inline void SymbolRuleProto::clear_has_apply_for_type() { + _has_bits_[0] &= ~0x00000002u; +} +inline void SymbolRuleProto::clear_apply_for_type() { + apply_for_type_ = 0; + clear_has_apply_for_type(); +} +inline ::google::protobuf::int32 SymbolRuleProto::apply_for_type() const { + return apply_for_type_; +} +inline void SymbolRuleProto::set_apply_for_type(::google::protobuf::int32 value) { + set_has_apply_for_type(); + apply_for_type_ = value; +} + +// required int32 priority = 3; +inline bool SymbolRuleProto::has_priority() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void SymbolRuleProto::set_has_priority() { + _has_bits_[0] |= 0x00000004u; +} +inline void SymbolRuleProto::clear_has_priority() { + _has_bits_[0] &= ~0x00000004u; +} +inline void SymbolRuleProto::clear_priority() { + priority_ = 0; + clear_has_priority(); +} +inline ::google::protobuf::int32 SymbolRuleProto::priority() const { + return priority_; +} +inline void SymbolRuleProto::set_priority(::google::protobuf::int32 value) { + set_has_priority(); + priority_ = value; +} + +// ------------------------------------------------------------------- + +// CaptionDefProto + +// required int32 height = 1; +inline bool CaptionDefProto::has_height() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void CaptionDefProto::set_has_height() { + _has_bits_[0] |= 0x00000001u; +} +inline void CaptionDefProto::clear_has_height() { + _has_bits_[0] &= ~0x00000001u; +} +inline void CaptionDefProto::clear_height() { + height_ = 0; + clear_has_height(); +} +inline ::google::protobuf::int32 CaptionDefProto::height() const { + return height_; +} +inline void CaptionDefProto::set_height(::google::protobuf::int32 value) { + set_has_height(); + height_ = value; +} + +// required uint32 color = 2; +inline bool CaptionDefProto::has_color() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void CaptionDefProto::set_has_color() { + _has_bits_[0] |= 0x00000002u; +} +inline void CaptionDefProto::clear_has_color() { + _has_bits_[0] &= ~0x00000002u; +} +inline void CaptionDefProto::clear_color() { + color_ = 0u; + clear_has_color(); +} +inline ::google::protobuf::uint32 CaptionDefProto::color() const { + return color_; +} +inline void CaptionDefProto::set_color(::google::protobuf::uint32 value) { + set_has_color(); + color_ = value; +} + +// optional uint32 stroke_color = 3; +inline bool CaptionDefProto::has_stroke_color() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void CaptionDefProto::set_has_stroke_color() { + _has_bits_[0] |= 0x00000004u; +} +inline void CaptionDefProto::clear_has_stroke_color() { + _has_bits_[0] &= ~0x00000004u; +} +inline void CaptionDefProto::clear_stroke_color() { + stroke_color_ = 0u; + clear_has_stroke_color(); +} +inline ::google::protobuf::uint32 CaptionDefProto::stroke_color() const { + return stroke_color_; +} +inline void CaptionDefProto::set_stroke_color(::google::protobuf::uint32 value) { + set_has_stroke_color(); + stroke_color_ = value; +} + +// ------------------------------------------------------------------- + +// CaptionRuleProto + +// required .CaptionDefProto primary = 1; +inline bool CaptionRuleProto::has_primary() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void CaptionRuleProto::set_has_primary() { + _has_bits_[0] |= 0x00000001u; +} +inline void CaptionRuleProto::clear_has_primary() { + _has_bits_[0] &= ~0x00000001u; +} +inline void CaptionRuleProto::clear_primary() { + if (primary_ != NULL) primary_->::CaptionDefProto::Clear(); + clear_has_primary(); +} +inline const ::CaptionDefProto& CaptionRuleProto::primary() const { + return primary_ != NULL ? *primary_ : *default_instance_->primary_; +} +inline ::CaptionDefProto* CaptionRuleProto::mutable_primary() { + set_has_primary(); + if (primary_ == NULL) primary_ = new ::CaptionDefProto; + return primary_; +} +inline ::CaptionDefProto* CaptionRuleProto::release_primary() { + clear_has_primary(); + ::CaptionDefProto* temp = primary_; + primary_ = NULL; + return temp; +} + +// optional .CaptionDefProto secondary = 2; +inline bool CaptionRuleProto::has_secondary() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void CaptionRuleProto::set_has_secondary() { + _has_bits_[0] |= 0x00000002u; +} +inline void CaptionRuleProto::clear_has_secondary() { + _has_bits_[0] &= ~0x00000002u; +} +inline void CaptionRuleProto::clear_secondary() { + if (secondary_ != NULL) secondary_->::CaptionDefProto::Clear(); + clear_has_secondary(); +} +inline const ::CaptionDefProto& CaptionRuleProto::secondary() const { + return secondary_ != NULL ? *secondary_ : *default_instance_->secondary_; +} +inline ::CaptionDefProto* CaptionRuleProto::mutable_secondary() { + set_has_secondary(); + if (secondary_ == NULL) secondary_ = new ::CaptionDefProto; + return secondary_; +} +inline ::CaptionDefProto* CaptionRuleProto::release_secondary() { + clear_has_secondary(); + ::CaptionDefProto* temp = secondary_; + secondary_ = NULL; + return temp; +} + +// required int32 priority = 3; +inline bool CaptionRuleProto::has_priority() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void CaptionRuleProto::set_has_priority() { + _has_bits_[0] |= 0x00000004u; +} +inline void CaptionRuleProto::clear_has_priority() { + _has_bits_[0] &= ~0x00000004u; +} +inline void CaptionRuleProto::clear_priority() { + priority_ = 0; + clear_has_priority(); +} +inline ::google::protobuf::int32 CaptionRuleProto::priority() const { + return priority_; +} +inline void CaptionRuleProto::set_priority(::google::protobuf::int32 value) { + set_has_priority(); + priority_ = value; +} + +// ------------------------------------------------------------------- + +// CircleRuleProto + +// required double radius = 1; +inline bool CircleRuleProto::has_radius() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void CircleRuleProto::set_has_radius() { + _has_bits_[0] |= 0x00000001u; +} +inline void CircleRuleProto::clear_has_radius() { + _has_bits_[0] &= ~0x00000001u; +} +inline void CircleRuleProto::clear_radius() { + radius_ = 0; + clear_has_radius(); +} +inline double CircleRuleProto::radius() const { + return radius_; +} +inline void CircleRuleProto::set_radius(double value) { + set_has_radius(); + radius_ = value; +} + +// required uint32 color = 2; +inline bool CircleRuleProto::has_color() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void CircleRuleProto::set_has_color() { + _has_bits_[0] |= 0x00000002u; +} +inline void CircleRuleProto::clear_has_color() { + _has_bits_[0] &= ~0x00000002u; +} +inline void CircleRuleProto::clear_color() { + color_ = 0u; + clear_has_color(); +} +inline ::google::protobuf::uint32 CircleRuleProto::color() const { + return color_; +} +inline void CircleRuleProto::set_color(::google::protobuf::uint32 value) { + set_has_color(); + color_ = value; +} + +// optional .LineDefProto border = 3; +inline bool CircleRuleProto::has_border() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void CircleRuleProto::set_has_border() { + _has_bits_[0] |= 0x00000004u; +} +inline void CircleRuleProto::clear_has_border() { + _has_bits_[0] &= ~0x00000004u; +} +inline void CircleRuleProto::clear_border() { + if (border_ != NULL) border_->::LineDefProto::Clear(); + clear_has_border(); +} +inline const ::LineDefProto& CircleRuleProto::border() const { + return border_ != NULL ? *border_ : *default_instance_->border_; +} +inline ::LineDefProto* CircleRuleProto::mutable_border() { + set_has_border(); + if (border_ == NULL) border_ = new ::LineDefProto; + return border_; +} +inline ::LineDefProto* CircleRuleProto::release_border() { + clear_has_border(); + ::LineDefProto* temp = border_; + border_ = NULL; + return temp; +} + +// required int32 priority = 4; +inline bool CircleRuleProto::has_priority() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void CircleRuleProto::set_has_priority() { + _has_bits_[0] |= 0x00000008u; +} +inline void CircleRuleProto::clear_has_priority() { + _has_bits_[0] &= ~0x00000008u; +} +inline void CircleRuleProto::clear_priority() { + priority_ = 0; + clear_has_priority(); +} +inline ::google::protobuf::int32 CircleRuleProto::priority() const { + return priority_; +} +inline void CircleRuleProto::set_priority(::google::protobuf::int32 value) { + set_has_priority(); + priority_ = value; +} + +// ------------------------------------------------------------------- + +// PathTextRuleProto + +// required .CaptionDefProto primary = 1; +inline bool PathTextRuleProto::has_primary() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void PathTextRuleProto::set_has_primary() { + _has_bits_[0] |= 0x00000001u; +} +inline void PathTextRuleProto::clear_has_primary() { + _has_bits_[0] &= ~0x00000001u; +} +inline void PathTextRuleProto::clear_primary() { + if (primary_ != NULL) primary_->::CaptionDefProto::Clear(); + clear_has_primary(); +} +inline const ::CaptionDefProto& PathTextRuleProto::primary() const { + return primary_ != NULL ? *primary_ : *default_instance_->primary_; +} +inline ::CaptionDefProto* PathTextRuleProto::mutable_primary() { + set_has_primary(); + if (primary_ == NULL) primary_ = new ::CaptionDefProto; + return primary_; +} +inline ::CaptionDefProto* PathTextRuleProto::release_primary() { + clear_has_primary(); + ::CaptionDefProto* temp = primary_; + primary_ = NULL; + return temp; +} + +// optional .CaptionDefProto secondary = 2; +inline bool PathTextRuleProto::has_secondary() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void PathTextRuleProto::set_has_secondary() { + _has_bits_[0] |= 0x00000002u; +} +inline void PathTextRuleProto::clear_has_secondary() { + _has_bits_[0] &= ~0x00000002u; +} +inline void PathTextRuleProto::clear_secondary() { + if (secondary_ != NULL) secondary_->::CaptionDefProto::Clear(); + clear_has_secondary(); +} +inline const ::CaptionDefProto& PathTextRuleProto::secondary() const { + return secondary_ != NULL ? *secondary_ : *default_instance_->secondary_; +} +inline ::CaptionDefProto* PathTextRuleProto::mutable_secondary() { + set_has_secondary(); + if (secondary_ == NULL) secondary_ = new ::CaptionDefProto; + return secondary_; +} +inline ::CaptionDefProto* PathTextRuleProto::release_secondary() { + clear_has_secondary(); + ::CaptionDefProto* temp = secondary_; + secondary_ = NULL; + return temp; +} + +// required int32 priority = 3; +inline bool PathTextRuleProto::has_priority() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void PathTextRuleProto::set_has_priority() { + _has_bits_[0] |= 0x00000004u; +} +inline void PathTextRuleProto::clear_has_priority() { + _has_bits_[0] &= ~0x00000004u; +} +inline void PathTextRuleProto::clear_priority() { + priority_ = 0; + clear_has_priority(); +} +inline ::google::protobuf::int32 PathTextRuleProto::priority() const { + return priority_; +} +inline void PathTextRuleProto::set_priority(::google::protobuf::int32 value) { + set_has_priority(); + priority_ = value; +} + +// ------------------------------------------------------------------- + +// DrawElementProto + +// required int32 scale = 1; +inline bool DrawElementProto::has_scale() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void DrawElementProto::set_has_scale() { + _has_bits_[0] |= 0x00000001u; +} +inline void DrawElementProto::clear_has_scale() { + _has_bits_[0] &= ~0x00000001u; +} +inline void DrawElementProto::clear_scale() { + scale_ = 0; + clear_has_scale(); +} +inline ::google::protobuf::int32 DrawElementProto::scale() const { + return scale_; +} +inline void DrawElementProto::set_scale(::google::protobuf::int32 value) { + set_has_scale(); + scale_ = value; +} + +// repeated .LineRuleProto lines = 2; +inline int DrawElementProto::lines_size() const { + return lines_.size(); +} +inline void DrawElementProto::clear_lines() { + lines_.Clear(); +} +inline const ::LineRuleProto& DrawElementProto::lines(int index) const { + return lines_.Get(index); +} +inline ::LineRuleProto* DrawElementProto::mutable_lines(int index) { + return lines_.Mutable(index); +} +inline ::LineRuleProto* DrawElementProto::add_lines() { + return lines_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::LineRuleProto >& +DrawElementProto::lines() const { + return lines_; +} +inline ::google::protobuf::RepeatedPtrField< ::LineRuleProto >* +DrawElementProto::mutable_lines() { + return &lines_; +} + +// optional .AreaRuleProto area = 3; +inline bool DrawElementProto::has_area() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void DrawElementProto::set_has_area() { + _has_bits_[0] |= 0x00000004u; +} +inline void DrawElementProto::clear_has_area() { + _has_bits_[0] &= ~0x00000004u; +} +inline void DrawElementProto::clear_area() { + if (area_ != NULL) area_->::AreaRuleProto::Clear(); + clear_has_area(); +} +inline const ::AreaRuleProto& DrawElementProto::area() const { + return area_ != NULL ? *area_ : *default_instance_->area_; +} +inline ::AreaRuleProto* DrawElementProto::mutable_area() { + set_has_area(); + if (area_ == NULL) area_ = new ::AreaRuleProto; + return area_; +} +inline ::AreaRuleProto* DrawElementProto::release_area() { + clear_has_area(); + ::AreaRuleProto* temp = area_; + area_ = NULL; + return temp; +} + +// optional .SymbolRuleProto symbol = 4; +inline bool DrawElementProto::has_symbol() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void DrawElementProto::set_has_symbol() { + _has_bits_[0] |= 0x00000008u; +} +inline void DrawElementProto::clear_has_symbol() { + _has_bits_[0] &= ~0x00000008u; +} +inline void DrawElementProto::clear_symbol() { + if (symbol_ != NULL) symbol_->::SymbolRuleProto::Clear(); + clear_has_symbol(); +} +inline const ::SymbolRuleProto& DrawElementProto::symbol() const { + return symbol_ != NULL ? *symbol_ : *default_instance_->symbol_; +} +inline ::SymbolRuleProto* DrawElementProto::mutable_symbol() { + set_has_symbol(); + if (symbol_ == NULL) symbol_ = new ::SymbolRuleProto; + return symbol_; +} +inline ::SymbolRuleProto* DrawElementProto::release_symbol() { + clear_has_symbol(); + ::SymbolRuleProto* temp = symbol_; + symbol_ = NULL; + return temp; +} + +// optional .CaptionRuleProto caption = 5; +inline bool DrawElementProto::has_caption() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void DrawElementProto::set_has_caption() { + _has_bits_[0] |= 0x00000010u; +} +inline void DrawElementProto::clear_has_caption() { + _has_bits_[0] &= ~0x00000010u; +} +inline void DrawElementProto::clear_caption() { + if (caption_ != NULL) caption_->::CaptionRuleProto::Clear(); + clear_has_caption(); +} +inline const ::CaptionRuleProto& DrawElementProto::caption() const { + return caption_ != NULL ? *caption_ : *default_instance_->caption_; +} +inline ::CaptionRuleProto* DrawElementProto::mutable_caption() { + set_has_caption(); + if (caption_ == NULL) caption_ = new ::CaptionRuleProto; + return caption_; +} +inline ::CaptionRuleProto* DrawElementProto::release_caption() { + clear_has_caption(); + ::CaptionRuleProto* temp = caption_; + caption_ = NULL; + return temp; +} + +// optional .CircleRuleProto circle = 6; +inline bool DrawElementProto::has_circle() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void DrawElementProto::set_has_circle() { + _has_bits_[0] |= 0x00000020u; +} +inline void DrawElementProto::clear_has_circle() { + _has_bits_[0] &= ~0x00000020u; +} +inline void DrawElementProto::clear_circle() { + if (circle_ != NULL) circle_->::CircleRuleProto::Clear(); + clear_has_circle(); +} +inline const ::CircleRuleProto& DrawElementProto::circle() const { + return circle_ != NULL ? *circle_ : *default_instance_->circle_; +} +inline ::CircleRuleProto* DrawElementProto::mutable_circle() { + set_has_circle(); + if (circle_ == NULL) circle_ = new ::CircleRuleProto; + return circle_; +} +inline ::CircleRuleProto* DrawElementProto::release_circle() { + clear_has_circle(); + ::CircleRuleProto* temp = circle_; + circle_ = NULL; + return temp; +} + +// optional .PathTextRuleProto path_text = 7; +inline bool DrawElementProto::has_path_text() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void DrawElementProto::set_has_path_text() { + _has_bits_[0] |= 0x00000040u; +} +inline void DrawElementProto::clear_has_path_text() { + _has_bits_[0] &= ~0x00000040u; +} +inline void DrawElementProto::clear_path_text() { + if (path_text_ != NULL) path_text_->::PathTextRuleProto::Clear(); + clear_has_path_text(); +} +inline const ::PathTextRuleProto& DrawElementProto::path_text() const { + return path_text_ != NULL ? *path_text_ : *default_instance_->path_text_; +} +inline ::PathTextRuleProto* DrawElementProto::mutable_path_text() { + set_has_path_text(); + if (path_text_ == NULL) path_text_ = new ::PathTextRuleProto; + return path_text_; +} +inline ::PathTextRuleProto* DrawElementProto::release_path_text() { + clear_has_path_text(); + ::PathTextRuleProto* temp = path_text_; + path_text_ = NULL; + return temp; +} + +// ------------------------------------------------------------------- + +// ClassifElementProto + +// required string name = 1; +inline bool ClassifElementProto::has_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ClassifElementProto::set_has_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void ClassifElementProto::clear_has_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ClassifElementProto::clear_name() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + clear_has_name(); +} +inline const ::std::string& ClassifElementProto::name() const { + return *name_; +} +inline void ClassifElementProto::set_name(const ::std::string& value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void ClassifElementProto::set_name(const char* value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void ClassifElementProto::set_name(const char* value, size_t size) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* ClassifElementProto::mutable_name() { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + return name_; +} +inline ::std::string* ClassifElementProto::release_name() { + clear_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = name_; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} + +// repeated .DrawElementProto element = 2; +inline int ClassifElementProto::element_size() const { + return element_.size(); +} +inline void ClassifElementProto::clear_element() { + element_.Clear(); +} +inline const ::DrawElementProto& ClassifElementProto::element(int index) const { + return element_.Get(index); +} +inline ::DrawElementProto* ClassifElementProto::mutable_element(int index) { + return element_.Mutable(index); +} +inline ::DrawElementProto* ClassifElementProto::add_element() { + return element_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::DrawElementProto >& +ClassifElementProto::element() const { + return element_; +} +inline ::google::protobuf::RepeatedPtrField< ::DrawElementProto >* +ClassifElementProto::mutable_element() { + return &element_; +} + +// ------------------------------------------------------------------- + +// ContainerProto + +// repeated .ClassifElementProto cont = 1; +inline int ContainerProto::cont_size() const { + return cont_.size(); +} +inline void ContainerProto::clear_cont() { + cont_.Clear(); +} +inline const ::ClassifElementProto& ContainerProto::cont(int index) const { + return cont_.Get(index); +} +inline ::ClassifElementProto* ContainerProto::mutable_cont(int index) { + return cont_.Mutable(index); +} +inline ::ClassifElementProto* ContainerProto::add_cont() { + return cont_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::ClassifElementProto >& +ContainerProto::cont() const { + return cont_; +} +inline ::google::protobuf::RepeatedPtrField< ::ClassifElementProto >* +ContainerProto::mutable_cont() { + return &cont_; +} + + +// @@protoc_insertion_point(namespace_scope) + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_drules_5fstruct_2eproto__INCLUDED diff --git a/indexer/indexer.pro b/indexer/indexer.pro index d44f87d82d..a9caa51f0d 100644 --- a/indexer/indexer.pro +++ b/indexer/indexer.pro @@ -40,8 +40,7 @@ SOURCES += \ index.cpp \ categories_holder.cpp \ search_string_utils.cpp \ - drules_struct.pb.cc \ - string_file.cpp + string_file.cpp \ HEADERS += \ feature.hpp \ @@ -87,8 +86,14 @@ HEADERS += \ mwm_set.hpp \ categories_holder.hpp \ drules_struct.pb.h \ - string_file.hpp + string_file.hpp \ OTHER_FILES += drules_struct.proto - +CONFIG(production) { + SOURCES += drules_struct_lite.pb.cc + HEADERS += drules_struct_lite.pb.h +} else { + SOURCES += drules_struct.pb.cc + HEADERS += drules_struct.pb.h +} diff --git a/map/proto_to_yg_styles.cpp b/map/proto_to_yg_styles.cpp index 37524c9bef..7f6c085ed0 100644 --- a/map/proto_to_yg_styles.cpp +++ b/map/proto_to_yg_styles.cpp @@ -1,6 +1,11 @@ #include "proto_to_yg_styles.hpp" -#include "../indexer/drules_struct.pb.h" +#ifdef OMIM_PRODUCTION + #include "../indexer/drules_struct_lite.pb.h" +#else + #include "../indexer/drules_struct.pb.h" +#endif + #include "../std/algorithm.hpp"