Generate drawing rules code.

1 files changed, 2217 insertions, 0 deletions

diff --git a/indexer/drules_struct.pb.cc b/indexer/drules_struct.pb.cc
new file mode 100644
index 0000000000..fe9e9ea58b
--- /dev/null
+++ b/indexer/drules_struct.pb.cc
@@ -0,0 +1,2217 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "drules_struct.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+// @@protoc_insertion_point(includes)
+
+void protobuf_ShutdownFile_drules_5fstruct_2eproto() {
+  delete ColorProto::default_instance_;
+  delete DashDotProto::default_instance_;
+  delete LineRuleProto::default_instance_;
+  delete AreaRuleProto::default_instance_;
+  delete SymbolRuleProto::default_instance_;
+  delete CaptionRuleProto::default_instance_;
+  delete CircleRuleProto::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;
+
+  ColorProto::default_instance_ = new ColorProto();
+  DashDotProto::default_instance_ = new DashDotProto();
+  LineRuleProto::default_instance_ = new LineRuleProto();
+  AreaRuleProto::default_instance_ = new AreaRuleProto();
+  SymbolRuleProto::default_instance_ = new SymbolRuleProto();
+  CaptionRuleProto::default_instance_ = new CaptionRuleProto();
+  CircleRuleProto::default_instance_ = new CircleRuleProto();
+  DrawElementProto::default_instance_ = new DrawElementProto();
+  ClassifElementProto::default_instance_ = new ClassifElementProto();
+  ContainerProto::default_instance_ = new ContainerProto();
+  ColorProto::default_instance_->InitAsDefaultInstance();
+  DashDotProto::default_instance_->InitAsDefaultInstance();
+  LineRuleProto::default_instance_->InitAsDefaultInstance();
+  AreaRuleProto::default_instance_->InitAsDefaultInstance();
+  SymbolRuleProto::default_instance_->InitAsDefaultInstance();
+  CaptionRuleProto::default_instance_->InitAsDefaultInstance();
+  CircleRuleProto::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 ColorProto::kColorFieldNumber;
+const int ColorProto::kOpacityFieldNumber;
+#endif  // !_MSC_VER
+
+ColorProto::ColorProto()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+}
+
+void ColorProto::InitAsDefaultInstance() {
+}
+
+ColorProto::ColorProto(const ColorProto& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void ColorProto::SharedCtor() {
+  _cached_size_ = 0;
+  color_ = 0;
+  opacity_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ColorProto::~ColorProto() {
+  SharedDtor();
+}
+
+void ColorProto::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void ColorProto::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ColorProto& ColorProto::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
+}
+
+ColorProto* ColorProto::default_instance_ = NULL;
+
+ColorProto* ColorProto::New() const {
+  return new ColorProto;
+}
+
+void ColorProto::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    color_ = 0;
+    opacity_ = 0;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+bool ColorProto::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 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::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &color_)));
+          set_has_color();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(16)) goto parse_opacity;
+        break;
+      }
+      
+      // optional int32 opacity = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_opacity:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &opacity_)));
+          set_has_opacity();
+        } 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 ColorProto::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // required int32 color = 1;
+  if (has_color()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->color(), output);
+  }
+  
+  // optional int32 opacity = 2;
+  if (has_opacity()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->opacity(), output);
+  }
+  
+}
+
+int ColorProto::ByteSize() const {
+  int total_size = 0;
+  
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required int32 color = 1;
+    if (has_color()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->color());
+    }
+    
+    // optional int32 opacity = 2;
+    if (has_opacity()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->opacity());
+    }
+    
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ColorProto::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ColorProto*>(&from));
+}
+
+void ColorProto::MergeFrom(const ColorProto& 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_opacity()) {
+      set_opacity(from.opacity());
+    }
+  }
+}
+
+void ColorProto::CopyFrom(const ColorProto& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ColorProto::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+  
+  return true;
+}
+
+void ColorProto::Swap(ColorProto* other) {
+  if (other != this) {
+    std::swap(color_, other->color_);
+    std::swap(opacity_, other->opacity_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string ColorProto::GetTypeName() const {
+  return "ColorProto";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int DashDotProto::kDdFieldNumber;
+#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;
+  ::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() {
+  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->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);
+  }
+  
+}
+
+int DashDotProto::ByteSize() const {
+  int total_size = 0;
+  
+  // 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<const DashDotProto*>(&from));
+}
+
+void DashDotProto::MergeFrom(const DashDotProto& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  dd_.MergeFrom(from.dd_);
+}
+
+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(_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;
+#endif  // !_MSC_VER
+
+LineRuleProto::LineRuleProto()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+}
+
+void LineRuleProto::InitAsDefaultInstance() {
+  color_ = const_cast< ::ColorProto*>(&::ColorProto::default_instance());
+  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_ = NULL;
+  dashdot_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+LineRuleProto::~LineRuleProto() {
+  SharedDtor();
+}
+
+void LineRuleProto::SharedDtor() {
+  if (this != default_instance_) {
+    delete color_;
+    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;
+    if (has_color()) {
+      if (color_ != NULL) color_->::ColorProto::Clear();
+    }
+    if (has_dashdot()) {
+      if (dashdot_ != NULL) dashdot_->::DashDotProto::Clear();
+    }
+  }
+  ::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(18)) goto parse_color;
+        break;
+      }
+      
+      // required .ColorProto color = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_color:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_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 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 .ColorProto color = 2;
+  if (has_color()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->color(), output);
+  }
+  
+  // optional .DashDotProto dashdot = 3;
+  if (has_dashdot()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      3, this->dashdot(), 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 .ColorProto color = 2;
+    if (has_color()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          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 LineRuleProto::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const LineRuleProto*>(&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()) {
+      mutable_color()->::ColorProto::MergeFrom(from.color());
+    }
+    if (from.has_dashdot()) {
+      mutable_dashdot()->::DashDotProto::MergeFrom(from.dashdot());
+    }
+  }
+}
+
+void LineRuleProto::CopyFrom(const LineRuleProto& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool LineRuleProto::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+  
+  if (has_color()) {
+    if (!this->color().IsInitialized()) 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(_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 AreaRuleProto::kColorFieldNumber;
+const int AreaRuleProto::kBorderFieldNumber;
+#endif  // !_MSC_VER
+
+AreaRuleProto::AreaRuleProto()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+}
+
+void AreaRuleProto::InitAsDefaultInstance() {
+  color_ = const_cast< ::ColorProto*>(&::ColorProto::default_instance());
+  border_ = const_cast< ::LineRuleProto*>(&::LineRuleProto::default_instance());
+}
+
+AreaRuleProto::AreaRuleProto(const AreaRuleProto& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void AreaRuleProto::SharedCtor() {
+  _cached_size_ = 0;
+  color_ = NULL;
+  border_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AreaRuleProto::~AreaRuleProto() {
+  SharedDtor();
+}
+
+void AreaRuleProto::SharedDtor() {
+  if (this != default_instance_) {
+    delete color_;
+    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))) {
+    if (has_color()) {
+      if (color_ != NULL) color_->::ColorProto::Clear();
+    }
+    if (has_border()) {
+      if (border_ != NULL) border_->::LineRuleProto::Clear();
+    }
+  }
+  ::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 .ColorProto color = 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_color()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_border;
+        break;
+      }
+      
+      // optional .LineRuleProto 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->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 .ColorProto color = 1;
+  if (has_color()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      1, this->color(), output);
+  }
+  
+  // optional .LineRuleProto border = 2;
+  if (has_border()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->border(), output);
+  }
+  
+}
+
+int AreaRuleProto::ByteSize() const {
+  int total_size = 0;
+  
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .ColorProto color = 1;
+    if (has_color()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->color());
+    }
+    
+    // optional .LineRuleProto border = 2;
+    if (has_border()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->border());
+    }
+    
+  }
+  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<const AreaRuleProto*>(&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()) {
+      mutable_color()->::ColorProto::MergeFrom(from.color());
+    }
+    if (from.has_border()) {
+      mutable_border()->::LineRuleProto::MergeFrom(from.border());
+    }
+  }
+}
+
+void AreaRuleProto::CopyFrom(const AreaRuleProto& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AreaRuleProto::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+  
+  if (has_color()) {
+    if (!this->color().IsInitialized()) 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(_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;
+#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);
+  ::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();
+      }
+    }
+  }
+  ::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->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);
+  }
+  
+}
+
+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());
+    }
+    
+  }
+  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<const SymbolRuleProto*>(&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());
+    }
+  }
+}
+
+void SymbolRuleProto::CopyFrom(const SymbolRuleProto& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SymbolRuleProto::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+  
+  return true;
+}
+
+void SymbolRuleProto::Swap(SymbolRuleProto* other) {
+  if (other != this) {
+    std::swap(name_, other->name_);
+    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 CaptionRuleProto::kHeightFieldNumber;
+const int CaptionRuleProto::kColorFieldNumber;
+const int CaptionRuleProto::kStrokeColorFieldNumber;
+#endif  // !_MSC_VER
+
+CaptionRuleProto::CaptionRuleProto()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+}
+
+void CaptionRuleProto::InitAsDefaultInstance() {
+  color_ = const_cast< ::ColorProto*>(&::ColorProto::default_instance());
+  stroke_color_ = const_cast< ::ColorProto*>(&::ColorProto::default_instance());
+}
+
+CaptionRuleProto::CaptionRuleProto(const CaptionRuleProto& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void CaptionRuleProto::SharedCtor() {
+  _cached_size_ = 0;
+  height_ = 0;
+  color_ = NULL;
+  stroke_color_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+CaptionRuleProto::~CaptionRuleProto() {
+  SharedDtor();
+}
+
+void CaptionRuleProto::SharedDtor() {
+  if (this != default_instance_) {
+    delete color_;
+    delete stroke_color_;
+  }
+}
+
+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))) {
+    height_ = 0;
+    if (has_color()) {
+      if (color_ != NULL) color_->::ColorProto::Clear();
+    }
+    if (has_stroke_color()) {
+      if (stroke_color_ != NULL) stroke_color_->::ColorProto::Clear();
+    }
+  }
+  ::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 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(18)) goto parse_color;
+        break;
+      }
+      
+      // optional .ColorProto color = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_color:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_color()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(26)) goto parse_stroke_color;
+        break;
+      }
+      
+      // optional .ColorProto stroke_color = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_stroke_color:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_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 CaptionRuleProto::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // required int32 height = 1;
+  if (has_height()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->height(), output);
+  }
+  
+  // optional .ColorProto color = 2;
+  if (has_color()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->color(), output);
+  }
+  
+  // optional .ColorProto stroke_color = 3;
+  if (has_stroke_color()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      3, this->stroke_color(), output);
+  }
+  
+}
+
+int CaptionRuleProto::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());
+    }
+    
+    // optional .ColorProto color = 2;
+    if (has_color()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->color());
+    }
+    
+    // optional .ColorProto stroke_color = 3;
+    if (has_stroke_color()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->stroke_color());
+    }
+    
+  }
+  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<const CaptionRuleProto*>(&from));
+}
+
+void CaptionRuleProto::MergeFrom(const CaptionRuleProto& 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()) {
+      mutable_color()->::ColorProto::MergeFrom(from.color());
+    }
+    if (from.has_stroke_color()) {
+      mutable_stroke_color()->::ColorProto::MergeFrom(from.stroke_color());
+    }
+  }
+}
+
+void CaptionRuleProto::CopyFrom(const CaptionRuleProto& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CaptionRuleProto::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+  
+  if (has_color()) {
+    if (!this->color().IsInitialized()) return false;
+  }
+  if (has_stroke_color()) {
+    if (!this->stroke_color().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void CaptionRuleProto::Swap(CaptionRuleProto* 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 CaptionRuleProto::GetTypeName() const {
+  return "CaptionRuleProto";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int CircleRuleProto::kRadFieldNumber;
+const int CircleRuleProto::kColorFieldNumber;
+const int CircleRuleProto::kBorderFieldNumber;
+#endif  // !_MSC_VER
+
+CircleRuleProto::CircleRuleProto()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+}
+
+void CircleRuleProto::InitAsDefaultInstance() {
+  color_ = const_cast< ::ColorProto*>(&::ColorProto::default_instance());
+  border_ = const_cast< ::LineRuleProto*>(&::LineRuleProto::default_instance());
+}
+
+CircleRuleProto::CircleRuleProto(const CircleRuleProto& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void CircleRuleProto::SharedCtor() {
+  _cached_size_ = 0;
+  rad_ = 0;
+  color_ = NULL;
+  border_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+CircleRuleProto::~CircleRuleProto() {
+  SharedDtor();
+}
+
+void CircleRuleProto::SharedDtor() {
+  if (this != default_instance_) {
+    delete color_;
+    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))) {
+    rad_ = 0;
+    if (has_color()) {
+      if (color_ != NULL) color_->::ColorProto::Clear();
+    }
+    if (has_border()) {
+      if (border_ != NULL) border_->::LineRuleProto::Clear();
+    }
+  }
+  ::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 rad = 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, &rad_)));
+          set_has_rad();
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_color;
+        break;
+      }
+      
+      // required .ColorProto color = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_color:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_color()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(26)) goto parse_border;
+        break;
+      }
+      
+      // optional .LineRuleProto 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->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 rad = 1;
+  if (has_rad()) {
+    ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->rad(), output);
+  }
+  
+  // required .ColorProto color = 2;
+  if (has_color()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->color(), output);
+  }
+  
+  // optional .LineRuleProto border = 3;
+  if (has_border()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      3, this->border(), output);
+  }
+  
+}
+
+int CircleRuleProto::ByteSize() const {
+  int total_size = 0;
+  
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required double rad = 1;
+    if (has_rad()) {
+      total_size += 1 + 8;
+    }
+    
+    // required .ColorProto color = 2;
+    if (has_color()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->color());
+    }
+    
+    // optional .LineRuleProto border = 3;
+    if (has_border()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->border());
+    }
+    
+  }
+  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<const CircleRuleProto*>(&from));
+}
+
+void CircleRuleProto::MergeFrom(const CircleRuleProto& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_rad()) {
+      set_rad(from.rad());
+    }
+    if (from.has_color()) {
+      mutable_color()->::ColorProto::MergeFrom(from.color());
+    }
+    if (from.has_border()) {
+      mutable_border()->::LineRuleProto::MergeFrom(from.border());
+    }
+  }
+}
+
+void CircleRuleProto::CopyFrom(const CircleRuleProto& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CircleRuleProto::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+  
+  if (has_color()) {
+    if (!this->color().IsInitialized()) return false;
+  }
+  if (has_border()) {
+    if (!this->border().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void CircleRuleProto::Swap(CircleRuleProto* other) {
+  if (other != this) {
+    std::swap(rad_, other->rad_);
+    std::swap(color_, other->color_);
+    std::swap(border_, other->border_);
+    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 DrawElementProto::kScaleFieldNumber;
+const int DrawElementProto::kLinesFieldNumber;
+const int DrawElementProto::kAreaFieldNumber;
+const int DrawElementProto::kSymFieldNumber;
+const int DrawElementProto::kCapFieldNumber;
+const int DrawElementProto::kCirFieldNumber;
+#endif  // !_MSC_VER
+
+DrawElementProto::DrawElementProto()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+}
+
+void DrawElementProto::InitAsDefaultInstance() {
+  area_ = const_cast< ::AreaRuleProto*>(&::AreaRuleProto::default_instance());
+  sym_ = const_cast< ::SymbolRuleProto*>(&::SymbolRuleProto::default_instance());
+  cap_ = const_cast< ::CaptionRuleProto*>(&::CaptionRuleProto::default_instance());
+  cir_ = const_cast< ::CircleRuleProto*>(&::CircleRuleProto::default_instance());
+}
+
+DrawElementProto::DrawElementProto(const DrawElementProto& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void DrawElementProto::SharedCtor() {
+  _cached_size_ = 0;
+  scale_ = 0;
+  area_ = NULL;
+  sym_ = NULL;
+  cap_ = NULL;
+  cir_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+DrawElementProto::~DrawElementProto() {
+  SharedDtor();
+}
+
+void DrawElementProto::SharedDtor() {
+  if (this != default_instance_) {
+    delete area_;
+    delete sym_;
+    delete cap_;
+    delete cir_;
+  }
+}
+
+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_sym()) {
+      if (sym_ != NULL) sym_->::SymbolRuleProto::Clear();
+    }
+    if (has_cap()) {
+      if (cap_ != NULL) cap_->::CaptionRuleProto::Clear();
+    }
+    if (has_cir()) {
+      if (cir_ != NULL) cir_->::CircleRuleProto::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_sym;
+        break;
+      }
+      
+      // optional .SymbolRuleProto sym = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_sym:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_sym()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(42)) goto parse_cap;
+        break;
+      }
+      
+      // optional .CaptionRuleProto cap = 5;
+      case 5: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_cap:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_cap()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(50)) goto parse_cir;
+        break;
+      }
+      
+      // optional .CircleRuleProto cir = 6;
+      case 6: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_cir:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_cir()));
+        } 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 sym = 4;
+  if (has_sym()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      4, this->sym(), output);
+  }
+  
+  // optional .CaptionRuleProto cap = 5;
+  if (has_cap()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      5, this->cap(), output);
+  }
+  
+  // optional .CircleRuleProto cir = 6;
+  if (has_cir()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      6, this->cir(), 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 sym = 4;
+    if (has_sym()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->sym());
+    }
+    
+    // optional .CaptionRuleProto cap = 5;
+    if (has_cap()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->cap());
+    }
+    
+    // optional .CircleRuleProto cir = 6;
+    if (has_cir()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->cir());
+    }
+    
+  }
+  // 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<const DrawElementProto*>(&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_sym()) {
+      mutable_sym()->::SymbolRuleProto::MergeFrom(from.sym());
+    }
+    if (from.has_cap()) {
+      mutable_cap()->::CaptionRuleProto::MergeFrom(from.cap());
+    }
+    if (from.has_cir()) {
+      mutable_cir()->::CircleRuleProto::MergeFrom(from.cir());
+    }
+  }
+}
+
+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_sym()) {
+    if (!this->sym().IsInitialized()) return false;
+  }
+  if (has_cap()) {
+    if (!this->cap().IsInitialized()) return false;
+  }
+  if (has_cir()) {
+    if (!this->cir().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(sym_, other->sym_);
+    std::swap(cap_, other->cap_);
+    std::swap(cir_, other->cir_);
+    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::kLinesFieldNumber;
+#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();
+      }
+    }
+  }
+  lines_.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_lines;
+        break;
+      }
+      
+      // repeated .DrawElementProto 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->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 lines = 2;
+  for (int i = 0; i < this->lines_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->lines(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 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 ClassifElementProto::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const ClassifElementProto*>(&from));
+}
+
+void ClassifElementProto::MergeFrom(const ClassifElementProto& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  lines_.MergeFrom(from.lines_);
+  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 < lines_size(); i++) {
+    if (!this->lines(i).IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClassifElementProto::Swap(ClassifElementProto* other) {
+  if (other != this) {
+    std::swap(name_, other->name_);
+    lines_.Swap(&other->lines_);
+    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<const ContainerProto*>(&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)