diff options
author | kshalnev <k.shalnev@gmail.com> | 2015-08-19 21:46:07 +0300 |
---|---|---|
committer | Alex Zolotarev <alex@maps.me> | 2015-09-23 03:02:05 +0300 |
commit | 1e6bad85f20e8ca2db8e1c2e438bbf7af455d9f6 (patch) | |
tree | 071cfec2e72c0e0f93f8d09919674da56c44cef5 /indexer | |
parent | 3738fe92f469a9722c72784e48f5a9dc037d5772 (diff) |
Added Shield class in proto, autogenerated files were updated
Diffstat (limited to 'indexer')
-rw-r--r-- | indexer/drules_struct.pb.cc | 355 | ||||
-rw-r--r-- | indexer/drules_struct.pb.h | 279 | ||||
-rw-r--r-- | indexer/drules_struct.proto | 9 |
3 files changed, 642 insertions, 1 deletions
diff --git a/indexer/drules_struct.pb.cc b/indexer/drules_struct.pb.cc index c8624cf730..cc95ab4de4 100644 --- a/indexer/drules_struct.pb.cc +++ b/indexer/drules_struct.pb.cc @@ -24,6 +24,7 @@ void protobuf_ShutdownFile_drules_5fstruct_2eproto() { delete CaptionRuleProto::default_instance_; delete CircleRuleProto::default_instance_; delete PathTextRuleProto::default_instance_; + delete ShieldRuleProto::default_instance_; delete DrawElementProto::default_instance_; delete ClassifElementProto::default_instance_; delete ContainerProto::default_instance_; @@ -51,6 +52,7 @@ void protobuf_AddDesc_drules_5fstruct_2eproto() { CaptionRuleProto::default_instance_ = new CaptionRuleProto(); CircleRuleProto::default_instance_ = new CircleRuleProto(); PathTextRuleProto::default_instance_ = new PathTextRuleProto(); + ShieldRuleProto::default_instance_ = new ShieldRuleProto(); DrawElementProto::default_instance_ = new DrawElementProto(); ClassifElementProto::default_instance_ = new ClassifElementProto(); ContainerProto::default_instance_ = new ContainerProto(); @@ -64,6 +66,7 @@ void protobuf_AddDesc_drules_5fstruct_2eproto() { CaptionRuleProto::default_instance_->InitAsDefaultInstance(); CircleRuleProto::default_instance_->InitAsDefaultInstance(); PathTextRuleProto::default_instance_->InitAsDefaultInstance(); + ShieldRuleProto::default_instance_->InitAsDefaultInstance(); DrawElementProto::default_instance_->InitAsDefaultInstance(); ClassifElementProto::default_instance_->InitAsDefaultInstance(); ContainerProto::default_instance_->InitAsDefaultInstance(); @@ -3253,6 +3256,311 @@ void PathTextRuleProto::Swap(PathTextRuleProto* other) { // =================================================================== #ifndef _MSC_VER +const int ShieldRuleProto::kHeightFieldNumber; +const int ShieldRuleProto::kColorFieldNumber; +const int ShieldRuleProto::kStrokeColorFieldNumber; +const int ShieldRuleProto::kPriorityFieldNumber; +#endif // !_MSC_VER + +ShieldRuleProto::ShieldRuleProto() + : ::google::protobuf::MessageLite() { + SharedCtor(); + // @@protoc_insertion_point(constructor:ShieldRuleProto) +} + +void ShieldRuleProto::InitAsDefaultInstance() { +} + +ShieldRuleProto::ShieldRuleProto(const ShieldRuleProto& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); + // @@protoc_insertion_point(copy_constructor:ShieldRuleProto) +} + +void ShieldRuleProto::SharedCtor() { + _cached_size_ = 0; + height_ = 0; + color_ = 0u; + stroke_color_ = 0u; + priority_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ShieldRuleProto::~ShieldRuleProto() { + // @@protoc_insertion_point(destructor:ShieldRuleProto) + SharedDtor(); +} + +void ShieldRuleProto::SharedDtor() { + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + if (this != &default_instance()) { + #else + if (this != default_instance_) { + #endif + } +} + +void ShieldRuleProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ShieldRuleProto& ShieldRuleProto::default_instance() { +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + protobuf_AddDesc_drules_5fstruct_2eproto(); +#else + if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto(); +#endif + return *default_instance_; +} + +ShieldRuleProto* ShieldRuleProto::default_instance_ = NULL; + +ShieldRuleProto* ShieldRuleProto::New() const { + return new ShieldRuleProto; +} + +void ShieldRuleProto::Clear() { +#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \ + &reinterpret_cast<ShieldRuleProto*>(16)->f) - \ + reinterpret_cast<char*>(16)) + +#define ZR_(first, last) do { \ + size_t f = OFFSET_OF_FIELD_(first); \ + size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \ + ::memset(&first, 0, n); \ + } while (0) + + ZR_(height_, priority_); + +#undef OFFSET_OF_FIELD_ +#undef ZR_ + + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->clear(); +} + +bool ShieldRuleProto::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + ::google::protobuf::io::StringOutputStream unknown_fields_string( + mutable_unknown_fields()); + ::google::protobuf::io::CodedOutputStream unknown_fields_stream( + &unknown_fields_string); + // @@protoc_insertion_point(parse_start:ShieldRuleProto) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required int32 height = 1; + case 1: { + if (tag == 8) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &height_))); + set_has_height(); + } else { + goto handle_unusual; + } + if (input->ExpectTag(16)) goto parse_color; + break; + } + + // required uint32 color = 2; + case 2: { + if (tag == 16) { + 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_unusual; + } + if (input->ExpectTag(24)) goto parse_stroke_color; + break; + } + + // optional uint32 stroke_color = 3; + case 3: { + if (tag == 24) { + 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_unusual; + } + if (input->ExpectTag(32)) goto parse_priority; + break; + } + + // required int32 priority = 4; + case 4: { + if (tag == 32) { + 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_unusual; + } + if (input->ExpectAtEnd()) goto success; + break; + } + + default: { + handle_unusual: + if (tag == 0 || + ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + goto success; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField( + input, tag, &unknown_fields_stream)); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:ShieldRuleProto) + return true; +failure: + // @@protoc_insertion_point(parse_failure:ShieldRuleProto) + return false; +#undef DO_ +} + +void ShieldRuleProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:ShieldRuleProto) + // 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); + } + + // required int32 priority = 4; + if (has_priority()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->priority(), output); + } + + output->WriteRaw(unknown_fields().data(), + unknown_fields().size()); + // @@protoc_insertion_point(serialize_end:ShieldRuleProto) +} + +int ShieldRuleProto::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()); + } + + // required int32 priority = 4; + if (has_priority()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->priority()); + } + + } + total_size += unknown_fields().size(); + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ShieldRuleProto::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast<const ShieldRuleProto*>(&from)); +} + +void ShieldRuleProto::MergeFrom(const ShieldRuleProto& 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()); + } + if (from.has_priority()) { + set_priority(from.priority()); + } + } + mutable_unknown_fields()->append(from.unknown_fields()); +} + +void ShieldRuleProto::CopyFrom(const ShieldRuleProto& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ShieldRuleProto::IsInitialized() const { + if ((_has_bits_[0] & 0x0000000b) != 0x0000000b) return false; + + return true; +} + +void ShieldRuleProto::Swap(ShieldRuleProto* other) { + if (other != this) { + std::swap(height_, other->height_); + std::swap(color_, other->color_); + std::swap(stroke_color_, other->stroke_color_); + std::swap(priority_, other->priority_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.swap(other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string ShieldRuleProto::GetTypeName() const { + return "ShieldRuleProto"; +} + + +// =================================================================== + +#ifndef _MSC_VER const int DrawElementProto::kScaleFieldNumber; const int DrawElementProto::kLinesFieldNumber; const int DrawElementProto::kAreaFieldNumber; @@ -3260,6 +3568,7 @@ const int DrawElementProto::kSymbolFieldNumber; const int DrawElementProto::kCaptionFieldNumber; const int DrawElementProto::kCircleFieldNumber; const int DrawElementProto::kPathTextFieldNumber; +const int DrawElementProto::kShieldFieldNumber; #endif // !_MSC_VER DrawElementProto::DrawElementProto() @@ -3299,6 +3608,12 @@ void DrawElementProto::InitAsDefaultInstance() { #else path_text_ = const_cast< ::PathTextRuleProto*>(&::PathTextRuleProto::default_instance()); #endif +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + shield_ = const_cast< ::ShieldRuleProto*>( + ::ShieldRuleProto::internal_default_instance()); +#else + shield_ = const_cast< ::ShieldRuleProto*>(&::ShieldRuleProto::default_instance()); +#endif } DrawElementProto::DrawElementProto(const DrawElementProto& from) @@ -3316,6 +3631,7 @@ void DrawElementProto::SharedCtor() { caption_ = NULL; circle_ = NULL; path_text_ = NULL; + shield_ = NULL; ::memset(_has_bits_, 0, sizeof(_has_bits_)); } @@ -3335,6 +3651,7 @@ void DrawElementProto::SharedDtor() { delete caption_; delete circle_; delete path_text_; + delete shield_; } } @@ -3359,7 +3676,7 @@ DrawElementProto* DrawElementProto::New() const { } void DrawElementProto::Clear() { - if (_has_bits_[0 / 32] & 125) { + if (_has_bits_[0 / 32] & 253) { scale_ = 0; if (has_area()) { if (area_ != NULL) area_->::AreaRuleProto::Clear(); @@ -3376,6 +3693,9 @@ void DrawElementProto::Clear() { if (has_path_text()) { if (path_text_ != NULL) path_text_->::PathTextRuleProto::Clear(); } + if (has_shield()) { + if (shield_ != NULL) shield_->::ShieldRuleProto::Clear(); + } } lines_.Clear(); ::memset(_has_bits_, 0, sizeof(_has_bits_)); @@ -3485,6 +3805,19 @@ bool DrawElementProto::MergePartialFromCodedStream( } else { goto handle_unusual; } + if (input->ExpectTag(66)) goto parse_shield; + break; + } + + // optional .ShieldRuleProto shield = 8; + case 8: { + if (tag == 66) { + parse_shield: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_shield())); + } else { + goto handle_unusual; + } if (input->ExpectAtEnd()) goto success; break; } @@ -3555,6 +3888,12 @@ void DrawElementProto::SerializeWithCachedSizes( 7, this->path_text(), output); } + // optional .ShieldRuleProto shield = 8; + if (has_shield()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 8, this->shield(), output); + } + output->WriteRaw(unknown_fields().data(), unknown_fields().size()); // @@protoc_insertion_point(serialize_end:DrawElementProto) @@ -3606,6 +3945,13 @@ int DrawElementProto::ByteSize() const { this->path_text()); } + // optional .ShieldRuleProto shield = 8; + if (has_shield()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->shield()); + } + } // repeated .LineRuleProto lines = 2; total_size += 1 * this->lines_size(); @@ -3650,6 +3996,9 @@ void DrawElementProto::MergeFrom(const DrawElementProto& from) { if (from.has_path_text()) { mutable_path_text()->::PathTextRuleProto::MergeFrom(from.path_text()); } + if (from.has_shield()) { + mutable_shield()->::ShieldRuleProto::MergeFrom(from.shield()); + } } mutable_unknown_fields()->append(from.unknown_fields()); } @@ -3679,6 +4028,9 @@ bool DrawElementProto::IsInitialized() const { if (has_path_text()) { if (!this->path_text().IsInitialized()) return false; } + if (has_shield()) { + if (!this->shield().IsInitialized()) return false; + } return true; } @@ -3691,6 +4043,7 @@ void DrawElementProto::Swap(DrawElementProto* other) { std::swap(caption_, other->caption_); std::swap(circle_, other->circle_); std::swap(path_text_, other->path_text_); + std::swap(shield_, other->shield_); std::swap(_has_bits_[0], other->_has_bits_[0]); _unknown_fields_.swap(other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); diff --git a/indexer/drules_struct.pb.h b/indexer/drules_struct.pb.h index 86128071f3..9d324dcaf9 100644 --- a/indexer/drules_struct.pb.h +++ b/indexer/drules_struct.pb.h @@ -40,6 +40,7 @@ class CaptionDefProto; class CaptionRuleProto; class CircleRuleProto; class PathTextRuleProto; +class ShieldRuleProto; class DrawElementProto; class ClassifElementProto; class ContainerProto; @@ -1299,6 +1300,127 @@ class PathTextRuleProto : public ::google::protobuf::MessageLite { }; // ------------------------------------------------------------------- +class ShieldRuleProto : public ::google::protobuf::MessageLite { + public: + ShieldRuleProto(); + virtual ~ShieldRuleProto(); + + ShieldRuleProto(const ShieldRuleProto& from); + + inline ShieldRuleProto& operator=(const ShieldRuleProto& from) { + CopyFrom(from); + return *this; + } + + inline const ::std::string& unknown_fields() const { + return _unknown_fields_; + } + + inline ::std::string* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ShieldRuleProto& default_instance(); + + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + // Returns the internal default instance pointer. This function can + // return NULL thus should not be used by the user. This is intended + // for Protobuf internal code. Please use default_instance() declared + // above instead. + static inline const ShieldRuleProto* internal_default_instance() { + return default_instance_; + } + #endif + + void Swap(ShieldRuleProto* other); + + // implements Message ---------------------------------------------- + + ShieldRuleProto* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const ShieldRuleProto& from); + void MergeFrom(const ShieldRuleProto& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + void DiscardUnknownFields(); + 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); + + // 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:ShieldRuleProto) + 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(); + inline void set_has_priority(); + inline void clear_has_priority(); + + ::std::string _unknown_fields_; + + ::google::protobuf::uint32 _has_bits_[1]; + mutable int _cached_size_; + ::google::protobuf::int32 height_; + ::google::protobuf::uint32 color_; + ::google::protobuf::uint32 stroke_color_; + ::google::protobuf::int32 priority_; + #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + friend void protobuf_AddDesc_drules_5fstruct_2eproto_impl(); + #else + friend void protobuf_AddDesc_drules_5fstruct_2eproto(); + #endif + friend void protobuf_AssignDesc_drules_5fstruct_2eproto(); + friend void protobuf_ShutdownFile_drules_5fstruct_2eproto(); + + void InitAsDefaultInstance(); + static ShieldRuleProto* default_instance_; +}; +// ------------------------------------------------------------------- + class DrawElementProto : public ::google::protobuf::MessageLite { public: DrawElementProto(); @@ -1424,6 +1546,15 @@ class DrawElementProto : public ::google::protobuf::MessageLite { inline ::PathTextRuleProto* release_path_text(); inline void set_allocated_path_text(::PathTextRuleProto* path_text); + // optional .ShieldRuleProto shield = 8; + inline bool has_shield() const; + inline void clear_shield(); + static const int kShieldFieldNumber = 8; + inline const ::ShieldRuleProto& shield() const; + inline ::ShieldRuleProto* mutable_shield(); + inline ::ShieldRuleProto* release_shield(); + inline void set_allocated_shield(::ShieldRuleProto* shield); + // @@protoc_insertion_point(class_scope:DrawElementProto) private: inline void set_has_scale(); @@ -1438,6 +1569,8 @@ class DrawElementProto : public ::google::protobuf::MessageLite { inline void clear_has_circle(); inline void set_has_path_text(); inline void clear_has_path_text(); + inline void set_has_shield(); + inline void clear_has_shield(); ::std::string _unknown_fields_; @@ -1449,6 +1582,7 @@ class DrawElementProto : public ::google::protobuf::MessageLite { ::CaptionRuleProto* caption_; ::CircleRuleProto* circle_; ::PathTextRuleProto* path_text_; + ::ShieldRuleProto* shield_; ::google::protobuf::int32 scale_; #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER friend void protobuf_AddDesc_drules_5fstruct_2eproto_impl(); @@ -2969,6 +3103,106 @@ inline void PathTextRuleProto::set_priority(::google::protobuf::int32 value) { // ------------------------------------------------------------------- +// ShieldRuleProto + +// required int32 height = 1; +inline bool ShieldRuleProto::has_height() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ShieldRuleProto::set_has_height() { + _has_bits_[0] |= 0x00000001u; +} +inline void ShieldRuleProto::clear_has_height() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ShieldRuleProto::clear_height() { + height_ = 0; + clear_has_height(); +} +inline ::google::protobuf::int32 ShieldRuleProto::height() const { + // @@protoc_insertion_point(field_get:ShieldRuleProto.height) + return height_; +} +inline void ShieldRuleProto::set_height(::google::protobuf::int32 value) { + set_has_height(); + height_ = value; + // @@protoc_insertion_point(field_set:ShieldRuleProto.height) +} + +// required uint32 color = 2; +inline bool ShieldRuleProto::has_color() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ShieldRuleProto::set_has_color() { + _has_bits_[0] |= 0x00000002u; +} +inline void ShieldRuleProto::clear_has_color() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ShieldRuleProto::clear_color() { + color_ = 0u; + clear_has_color(); +} +inline ::google::protobuf::uint32 ShieldRuleProto::color() const { + // @@protoc_insertion_point(field_get:ShieldRuleProto.color) + return color_; +} +inline void ShieldRuleProto::set_color(::google::protobuf::uint32 value) { + set_has_color(); + color_ = value; + // @@protoc_insertion_point(field_set:ShieldRuleProto.color) +} + +// optional uint32 stroke_color = 3; +inline bool ShieldRuleProto::has_stroke_color() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void ShieldRuleProto::set_has_stroke_color() { + _has_bits_[0] |= 0x00000004u; +} +inline void ShieldRuleProto::clear_has_stroke_color() { + _has_bits_[0] &= ~0x00000004u; +} +inline void ShieldRuleProto::clear_stroke_color() { + stroke_color_ = 0u; + clear_has_stroke_color(); +} +inline ::google::protobuf::uint32 ShieldRuleProto::stroke_color() const { + // @@protoc_insertion_point(field_get:ShieldRuleProto.stroke_color) + return stroke_color_; +} +inline void ShieldRuleProto::set_stroke_color(::google::protobuf::uint32 value) { + set_has_stroke_color(); + stroke_color_ = value; + // @@protoc_insertion_point(field_set:ShieldRuleProto.stroke_color) +} + +// required int32 priority = 4; +inline bool ShieldRuleProto::has_priority() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void ShieldRuleProto::set_has_priority() { + _has_bits_[0] |= 0x00000008u; +} +inline void ShieldRuleProto::clear_has_priority() { + _has_bits_[0] &= ~0x00000008u; +} +inline void ShieldRuleProto::clear_priority() { + priority_ = 0; + clear_has_priority(); +} +inline ::google::protobuf::int32 ShieldRuleProto::priority() const { + // @@protoc_insertion_point(field_get:ShieldRuleProto.priority) + return priority_; +} +inline void ShieldRuleProto::set_priority(::google::protobuf::int32 value) { + set_has_priority(); + priority_ = value; + // @@protoc_insertion_point(field_set:ShieldRuleProto.priority) +} + +// ------------------------------------------------------------------- + // DrawElementProto // required int32 scale = 1; @@ -3250,6 +3484,51 @@ inline void DrawElementProto::set_allocated_path_text(::PathTextRuleProto* path_ // @@protoc_insertion_point(field_set_allocated:DrawElementProto.path_text) } +// optional .ShieldRuleProto shield = 8; +inline bool DrawElementProto::has_shield() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void DrawElementProto::set_has_shield() { + _has_bits_[0] |= 0x00000080u; +} +inline void DrawElementProto::clear_has_shield() { + _has_bits_[0] &= ~0x00000080u; +} +inline void DrawElementProto::clear_shield() { + if (shield_ != NULL) shield_->::ShieldRuleProto::Clear(); + clear_has_shield(); +} +inline const ::ShieldRuleProto& DrawElementProto::shield() const { + // @@protoc_insertion_point(field_get:DrawElementProto.shield) +#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER + return shield_ != NULL ? *shield_ : *default_instance().shield_; +#else + return shield_ != NULL ? *shield_ : *default_instance_->shield_; +#endif +} +inline ::ShieldRuleProto* DrawElementProto::mutable_shield() { + set_has_shield(); + if (shield_ == NULL) shield_ = new ::ShieldRuleProto; + // @@protoc_insertion_point(field_mutable:DrawElementProto.shield) + return shield_; +} +inline ::ShieldRuleProto* DrawElementProto::release_shield() { + clear_has_shield(); + ::ShieldRuleProto* temp = shield_; + shield_ = NULL; + return temp; +} +inline void DrawElementProto::set_allocated_shield(::ShieldRuleProto* shield) { + delete shield_; + shield_ = shield; + if (shield) { + set_has_shield(); + } else { + clear_has_shield(); + } + // @@protoc_insertion_point(field_set_allocated:DrawElementProto.shield) +} + // ------------------------------------------------------------------- // ClassifElementProto diff --git a/indexer/drules_struct.proto b/indexer/drules_struct.proto index e6412fd55f..9a18a68497 100644 --- a/indexer/drules_struct.proto +++ b/indexer/drules_struct.proto @@ -93,6 +93,14 @@ message PathTextRuleProto required int32 priority = 3; } +message ShieldRuleProto +{ + required int32 height = 1; + required uint32 color = 2; + optional uint32 stroke_color = 3; + required int32 priority = 4; +} + message DrawElementProto { required int32 scale = 1; @@ -102,6 +110,7 @@ message DrawElementProto optional CaptionRuleProto caption = 5; optional CircleRuleProto circle = 6; optional PathTextRuleProto path_text = 7; + optional ShieldRuleProto shield = 8; } message ClassifElementProto |