Added Shield class in proto, autogenerated files were updated

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