[search] Use protobuf in lite mode for production configuration.

1 files changed, 2233 insertions, 0 deletions

diff --git a/indexer/drules_struct_lite.pb.h b/indexer/drules_struct_lite.pb.h
new file mode 100644
index 0000000000..38b11b5d7c
--- /dev/null
+++ b/indexer/drules_struct_lite.pb.h
@@ -0,0 +1,2233 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: drules_struct.proto
+
+#ifndef PROTOBUF_drules_5fstruct_2eproto__INCLUDED
+#define PROTOBUF_drules_5fstruct_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2004000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2004001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+// @@protoc_insertion_point(includes)
+
+// Internal implementation detail -- do not call these.
+void  protobuf_AddDesc_drules_5fstruct_2eproto();
+void protobuf_AssignDesc_drules_5fstruct_2eproto();
+void protobuf_ShutdownFile_drules_5fstruct_2eproto();
+
+class DashDotProto;
+class LineRuleProto;
+class LineDefProto;
+class AreaRuleProto;
+class SymbolRuleProto;
+class CaptionDefProto;
+class CaptionRuleProto;
+class CircleRuleProto;
+class PathTextRuleProto;
+class DrawElementProto;
+class ClassifElementProto;
+class ContainerProto;
+
+// ===================================================================
+
+class DashDotProto : public ::google::protobuf::MessageLite {
+ public:
+  DashDotProto();
+  virtual ~DashDotProto();
+
+  DashDotProto(const DashDotProto& from);
+
+  inline DashDotProto& operator=(const DashDotProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  static const DashDotProto& default_instance();
+
+  void Swap(DashDotProto* other);
+
+  // implements Message ----------------------------------------------
+
+  DashDotProto* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const DashDotProto& from);
+  void MergeFrom(const DashDotProto& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated double dd = 1;
+  inline int dd_size() const;
+  inline void clear_dd();
+  static const int kDdFieldNumber = 1;
+  inline double dd(int index) const;
+  inline void set_dd(int index, double value);
+  inline void add_dd(double value);
+  inline const ::google::protobuf::RepeatedField< double >&
+      dd() const;
+  inline ::google::protobuf::RepeatedField< double >*
+      mutable_dd();
+
+  // optional double offset = 2;
+  inline bool has_offset() const;
+  inline void clear_offset();
+  static const int kOffsetFieldNumber = 2;
+  inline double offset() const;
+  inline void set_offset(double value);
+
+  // @@protoc_insertion_point(class_scope:DashDotProto)
+ private:
+  inline void set_has_offset();
+  inline void clear_has_offset();
+
+  ::google::protobuf::RepeatedField< double > dd_;
+  double offset_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
+
+  friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
+  friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
+  friend void protobuf_ShutdownFile_drules_5fstruct_2eproto();
+
+  void InitAsDefaultInstance();
+  static DashDotProto* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class LineRuleProto : public ::google::protobuf::MessageLite {
+ public:
+  LineRuleProto();
+  virtual ~LineRuleProto();
+
+  LineRuleProto(const LineRuleProto& from);
+
+  inline LineRuleProto& operator=(const LineRuleProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  static const LineRuleProto& default_instance();
+
+  void Swap(LineRuleProto* other);
+
+  // implements Message ----------------------------------------------
+
+  LineRuleProto* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const LineRuleProto& from);
+  void MergeFrom(const LineRuleProto& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required double width = 1;
+  inline bool has_width() const;
+  inline void clear_width();
+  static const int kWidthFieldNumber = 1;
+  inline double width() const;
+  inline void set_width(double value);
+
+  // required uint32 color = 2;
+  inline bool has_color() const;
+  inline void clear_color();
+  static const int kColorFieldNumber = 2;
+  inline ::google::protobuf::uint32 color() const;
+  inline void set_color(::google::protobuf::uint32 value);
+
+  // optional .DashDotProto dashdot = 3;
+  inline bool has_dashdot() const;
+  inline void clear_dashdot();
+  static const int kDashdotFieldNumber = 3;
+  inline const ::DashDotProto& dashdot() const;
+  inline ::DashDotProto* mutable_dashdot();
+  inline ::DashDotProto* release_dashdot();
+
+  // required int32 priority = 4;
+  inline bool has_priority() const;
+  inline void clear_priority();
+  static const int kPriorityFieldNumber = 4;
+  inline ::google::protobuf::int32 priority() const;
+  inline void set_priority(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:LineRuleProto)
+ private:
+  inline void set_has_width();
+  inline void clear_has_width();
+  inline void set_has_color();
+  inline void clear_has_color();
+  inline void set_has_dashdot();
+  inline void clear_has_dashdot();
+  inline void set_has_priority();
+  inline void clear_has_priority();
+
+  double width_;
+  ::DashDotProto* dashdot_;
+  ::google::protobuf::uint32 color_;
+  ::google::protobuf::int32 priority_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
+
+  friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
+  friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
+  friend void protobuf_ShutdownFile_drules_5fstruct_2eproto();
+
+  void InitAsDefaultInstance();
+  static LineRuleProto* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class LineDefProto : public ::google::protobuf::MessageLite {
+ public:
+  LineDefProto();
+  virtual ~LineDefProto();
+
+  LineDefProto(const LineDefProto& from);
+
+  inline LineDefProto& operator=(const LineDefProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  static const LineDefProto& default_instance();
+
+  void Swap(LineDefProto* other);
+
+  // implements Message ----------------------------------------------
+
+  LineDefProto* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const LineDefProto& from);
+  void MergeFrom(const LineDefProto& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required double width = 1;
+  inline bool has_width() const;
+  inline void clear_width();
+  static const int kWidthFieldNumber = 1;
+  inline double width() const;
+  inline void set_width(double value);
+
+  // required uint32 color = 2;
+  inline bool has_color() const;
+  inline void clear_color();
+  static const int kColorFieldNumber = 2;
+  inline ::google::protobuf::uint32 color() const;
+  inline void set_color(::google::protobuf::uint32 value);
+
+  // optional .DashDotProto dashdot = 3;
+  inline bool has_dashdot() const;
+  inline void clear_dashdot();
+  static const int kDashdotFieldNumber = 3;
+  inline const ::DashDotProto& dashdot() const;
+  inline ::DashDotProto* mutable_dashdot();
+  inline ::DashDotProto* release_dashdot();
+
+  // @@protoc_insertion_point(class_scope:LineDefProto)
+ private:
+  inline void set_has_width();
+  inline void clear_has_width();
+  inline void set_has_color();
+  inline void clear_has_color();
+  inline void set_has_dashdot();
+  inline void clear_has_dashdot();
+
+  double width_;
+  ::DashDotProto* dashdot_;
+  ::google::protobuf::uint32 color_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
+
+  friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
+  friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
+  friend void protobuf_ShutdownFile_drules_5fstruct_2eproto();
+
+  void InitAsDefaultInstance();
+  static LineDefProto* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class AreaRuleProto : public ::google::protobuf::MessageLite {
+ public:
+  AreaRuleProto();
+  virtual ~AreaRuleProto();
+
+  AreaRuleProto(const AreaRuleProto& from);
+
+  inline AreaRuleProto& operator=(const AreaRuleProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  static const AreaRuleProto& default_instance();
+
+  void Swap(AreaRuleProto* other);
+
+  // implements Message ----------------------------------------------
+
+  AreaRuleProto* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const AreaRuleProto& from);
+  void MergeFrom(const AreaRuleProto& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required uint32 color = 1;
+  inline bool has_color() const;
+  inline void clear_color();
+  static const int kColorFieldNumber = 1;
+  inline ::google::protobuf::uint32 color() const;
+  inline void set_color(::google::protobuf::uint32 value);
+
+  // optional .LineDefProto border = 2;
+  inline bool has_border() const;
+  inline void clear_border();
+  static const int kBorderFieldNumber = 2;
+  inline const ::LineDefProto& border() const;
+  inline ::LineDefProto* mutable_border();
+  inline ::LineDefProto* release_border();
+
+  // required int32 priority = 3;
+  inline bool has_priority() const;
+  inline void clear_priority();
+  static const int kPriorityFieldNumber = 3;
+  inline ::google::protobuf::int32 priority() const;
+  inline void set_priority(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:AreaRuleProto)
+ private:
+  inline void set_has_color();
+  inline void clear_has_color();
+  inline void set_has_border();
+  inline void clear_has_border();
+  inline void set_has_priority();
+  inline void clear_has_priority();
+
+  ::LineDefProto* border_;
+  ::google::protobuf::uint32 color_;
+  ::google::protobuf::int32 priority_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
+
+  friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
+  friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
+  friend void protobuf_ShutdownFile_drules_5fstruct_2eproto();
+
+  void InitAsDefaultInstance();
+  static AreaRuleProto* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class SymbolRuleProto : public ::google::protobuf::MessageLite {
+ public:
+  SymbolRuleProto();
+  virtual ~SymbolRuleProto();
+
+  SymbolRuleProto(const SymbolRuleProto& from);
+
+  inline SymbolRuleProto& operator=(const SymbolRuleProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  static const SymbolRuleProto& default_instance();
+
+  void Swap(SymbolRuleProto* other);
+
+  // implements Message ----------------------------------------------
+
+  SymbolRuleProto* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const SymbolRuleProto& from);
+  void MergeFrom(const SymbolRuleProto& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required string name = 1;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 1;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+
+  // optional int32 apply_for_type = 2;
+  inline bool has_apply_for_type() const;
+  inline void clear_apply_for_type();
+  static const int kApplyForTypeFieldNumber = 2;
+  inline ::google::protobuf::int32 apply_for_type() const;
+  inline void set_apply_for_type(::google::protobuf::int32 value);
+
+  // required int32 priority = 3;
+  inline bool has_priority() const;
+  inline void clear_priority();
+  static const int kPriorityFieldNumber = 3;
+  inline ::google::protobuf::int32 priority() const;
+  inline void set_priority(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:SymbolRuleProto)
+ private:
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_apply_for_type();
+  inline void clear_has_apply_for_type();
+  inline void set_has_priority();
+  inline void clear_has_priority();
+
+  ::std::string* name_;
+  ::google::protobuf::int32 apply_for_type_;
+  ::google::protobuf::int32 priority_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
+
+  friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
+  friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
+  friend void protobuf_ShutdownFile_drules_5fstruct_2eproto();
+
+  void InitAsDefaultInstance();
+  static SymbolRuleProto* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class CaptionDefProto : public ::google::protobuf::MessageLite {
+ public:
+  CaptionDefProto();
+  virtual ~CaptionDefProto();
+
+  CaptionDefProto(const CaptionDefProto& from);
+
+  inline CaptionDefProto& operator=(const CaptionDefProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  static const CaptionDefProto& default_instance();
+
+  void Swap(CaptionDefProto* other);
+
+  // implements Message ----------------------------------------------
+
+  CaptionDefProto* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const CaptionDefProto& from);
+  void MergeFrom(const CaptionDefProto& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required int32 height = 1;
+  inline bool has_height() const;
+  inline void clear_height();
+  static const int kHeightFieldNumber = 1;
+  inline ::google::protobuf::int32 height() const;
+  inline void set_height(::google::protobuf::int32 value);
+
+  // required uint32 color = 2;
+  inline bool has_color() const;
+  inline void clear_color();
+  static const int kColorFieldNumber = 2;
+  inline ::google::protobuf::uint32 color() const;
+  inline void set_color(::google::protobuf::uint32 value);
+
+  // optional uint32 stroke_color = 3;
+  inline bool has_stroke_color() const;
+  inline void clear_stroke_color();
+  static const int kStrokeColorFieldNumber = 3;
+  inline ::google::protobuf::uint32 stroke_color() const;
+  inline void set_stroke_color(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:CaptionDefProto)
+ private:
+  inline void set_has_height();
+  inline void clear_has_height();
+  inline void set_has_color();
+  inline void clear_has_color();
+  inline void set_has_stroke_color();
+  inline void clear_has_stroke_color();
+
+  ::google::protobuf::int32 height_;
+  ::google::protobuf::uint32 color_;
+  ::google::protobuf::uint32 stroke_color_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
+
+  friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
+  friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
+  friend void protobuf_ShutdownFile_drules_5fstruct_2eproto();
+
+  void InitAsDefaultInstance();
+  static CaptionDefProto* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class CaptionRuleProto : public ::google::protobuf::MessageLite {
+ public:
+  CaptionRuleProto();
+  virtual ~CaptionRuleProto();
+
+  CaptionRuleProto(const CaptionRuleProto& from);
+
+  inline CaptionRuleProto& operator=(const CaptionRuleProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  static const CaptionRuleProto& default_instance();
+
+  void Swap(CaptionRuleProto* other);
+
+  // implements Message ----------------------------------------------
+
+  CaptionRuleProto* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const CaptionRuleProto& from);
+  void MergeFrom(const CaptionRuleProto& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required .CaptionDefProto primary = 1;
+  inline bool has_primary() const;
+  inline void clear_primary();
+  static const int kPrimaryFieldNumber = 1;
+  inline const ::CaptionDefProto& primary() const;
+  inline ::CaptionDefProto* mutable_primary();
+  inline ::CaptionDefProto* release_primary();
+
+  // optional .CaptionDefProto secondary = 2;
+  inline bool has_secondary() const;
+  inline void clear_secondary();
+  static const int kSecondaryFieldNumber = 2;
+  inline const ::CaptionDefProto& secondary() const;
+  inline ::CaptionDefProto* mutable_secondary();
+  inline ::CaptionDefProto* release_secondary();
+
+  // required int32 priority = 3;
+  inline bool has_priority() const;
+  inline void clear_priority();
+  static const int kPriorityFieldNumber = 3;
+  inline ::google::protobuf::int32 priority() const;
+  inline void set_priority(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:CaptionRuleProto)
+ private:
+  inline void set_has_primary();
+  inline void clear_has_primary();
+  inline void set_has_secondary();
+  inline void clear_has_secondary();
+  inline void set_has_priority();
+  inline void clear_has_priority();
+
+  ::CaptionDefProto* primary_;
+  ::CaptionDefProto* secondary_;
+  ::google::protobuf::int32 priority_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
+
+  friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
+  friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
+  friend void protobuf_ShutdownFile_drules_5fstruct_2eproto();
+
+  void InitAsDefaultInstance();
+  static CaptionRuleProto* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class CircleRuleProto : public ::google::protobuf::MessageLite {
+ public:
+  CircleRuleProto();
+  virtual ~CircleRuleProto();
+
+  CircleRuleProto(const CircleRuleProto& from);
+
+  inline CircleRuleProto& operator=(const CircleRuleProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  static const CircleRuleProto& default_instance();
+
+  void Swap(CircleRuleProto* other);
+
+  // implements Message ----------------------------------------------
+
+  CircleRuleProto* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const CircleRuleProto& from);
+  void MergeFrom(const CircleRuleProto& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required double radius = 1;
+  inline bool has_radius() const;
+  inline void clear_radius();
+  static const int kRadiusFieldNumber = 1;
+  inline double radius() const;
+  inline void set_radius(double value);
+
+  // required uint32 color = 2;
+  inline bool has_color() const;
+  inline void clear_color();
+  static const int kColorFieldNumber = 2;
+  inline ::google::protobuf::uint32 color() const;
+  inline void set_color(::google::protobuf::uint32 value);
+
+  // optional .LineDefProto border = 3;
+  inline bool has_border() const;
+  inline void clear_border();
+  static const int kBorderFieldNumber = 3;
+  inline const ::LineDefProto& border() const;
+  inline ::LineDefProto* mutable_border();
+  inline ::LineDefProto* release_border();
+
+  // required int32 priority = 4;
+  inline bool has_priority() const;
+  inline void clear_priority();
+  static const int kPriorityFieldNumber = 4;
+  inline ::google::protobuf::int32 priority() const;
+  inline void set_priority(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:CircleRuleProto)
+ private:
+  inline void set_has_radius();
+  inline void clear_has_radius();
+  inline void set_has_color();
+  inline void clear_has_color();
+  inline void set_has_border();
+  inline void clear_has_border();
+  inline void set_has_priority();
+  inline void clear_has_priority();
+
+  double radius_;
+  ::LineDefProto* border_;
+  ::google::protobuf::uint32 color_;
+  ::google::protobuf::int32 priority_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
+
+  friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
+  friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
+  friend void protobuf_ShutdownFile_drules_5fstruct_2eproto();
+
+  void InitAsDefaultInstance();
+  static CircleRuleProto* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class PathTextRuleProto : public ::google::protobuf::MessageLite {
+ public:
+  PathTextRuleProto();
+  virtual ~PathTextRuleProto();
+
+  PathTextRuleProto(const PathTextRuleProto& from);
+
+  inline PathTextRuleProto& operator=(const PathTextRuleProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  static const PathTextRuleProto& default_instance();
+
+  void Swap(PathTextRuleProto* other);
+
+  // implements Message ----------------------------------------------
+
+  PathTextRuleProto* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const PathTextRuleProto& from);
+  void MergeFrom(const PathTextRuleProto& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required .CaptionDefProto primary = 1;
+  inline bool has_primary() const;
+  inline void clear_primary();
+  static const int kPrimaryFieldNumber = 1;
+  inline const ::CaptionDefProto& primary() const;
+  inline ::CaptionDefProto* mutable_primary();
+  inline ::CaptionDefProto* release_primary();
+
+  // optional .CaptionDefProto secondary = 2;
+  inline bool has_secondary() const;
+  inline void clear_secondary();
+  static const int kSecondaryFieldNumber = 2;
+  inline const ::CaptionDefProto& secondary() const;
+  inline ::CaptionDefProto* mutable_secondary();
+  inline ::CaptionDefProto* release_secondary();
+
+  // required int32 priority = 3;
+  inline bool has_priority() const;
+  inline void clear_priority();
+  static const int kPriorityFieldNumber = 3;
+  inline ::google::protobuf::int32 priority() const;
+  inline void set_priority(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:PathTextRuleProto)
+ private:
+  inline void set_has_primary();
+  inline void clear_has_primary();
+  inline void set_has_secondary();
+  inline void clear_has_secondary();
+  inline void set_has_priority();
+  inline void clear_has_priority();
+
+  ::CaptionDefProto* primary_;
+  ::CaptionDefProto* secondary_;
+  ::google::protobuf::int32 priority_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
+
+  friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
+  friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
+  friend void protobuf_ShutdownFile_drules_5fstruct_2eproto();
+
+  void InitAsDefaultInstance();
+  static PathTextRuleProto* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class DrawElementProto : public ::google::protobuf::MessageLite {
+ public:
+  DrawElementProto();
+  virtual ~DrawElementProto();
+
+  DrawElementProto(const DrawElementProto& from);
+
+  inline DrawElementProto& operator=(const DrawElementProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  static const DrawElementProto& default_instance();
+
+  void Swap(DrawElementProto* other);
+
+  // implements Message ----------------------------------------------
+
+  DrawElementProto* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const DrawElementProto& from);
+  void MergeFrom(const DrawElementProto& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required int32 scale = 1;
+  inline bool has_scale() const;
+  inline void clear_scale();
+  static const int kScaleFieldNumber = 1;
+  inline ::google::protobuf::int32 scale() const;
+  inline void set_scale(::google::protobuf::int32 value);
+
+  // repeated .LineRuleProto lines = 2;
+  inline int lines_size() const;
+  inline void clear_lines();
+  static const int kLinesFieldNumber = 2;
+  inline const ::LineRuleProto& lines(int index) const;
+  inline ::LineRuleProto* mutable_lines(int index);
+  inline ::LineRuleProto* add_lines();
+  inline const ::google::protobuf::RepeatedPtrField< ::LineRuleProto >&
+      lines() const;
+  inline ::google::protobuf::RepeatedPtrField< ::LineRuleProto >*
+      mutable_lines();
+
+  // optional .AreaRuleProto area = 3;
+  inline bool has_area() const;
+  inline void clear_area();
+  static const int kAreaFieldNumber = 3;
+  inline const ::AreaRuleProto& area() const;
+  inline ::AreaRuleProto* mutable_area();
+  inline ::AreaRuleProto* release_area();
+
+  // optional .SymbolRuleProto symbol = 4;
+  inline bool has_symbol() const;
+  inline void clear_symbol();
+  static const int kSymbolFieldNumber = 4;
+  inline const ::SymbolRuleProto& symbol() const;
+  inline ::SymbolRuleProto* mutable_symbol();
+  inline ::SymbolRuleProto* release_symbol();
+
+  // optional .CaptionRuleProto caption = 5;
+  inline bool has_caption() const;
+  inline void clear_caption();
+  static const int kCaptionFieldNumber = 5;
+  inline const ::CaptionRuleProto& caption() const;
+  inline ::CaptionRuleProto* mutable_caption();
+  inline ::CaptionRuleProto* release_caption();
+
+  // optional .CircleRuleProto circle = 6;
+  inline bool has_circle() const;
+  inline void clear_circle();
+  static const int kCircleFieldNumber = 6;
+  inline const ::CircleRuleProto& circle() const;
+  inline ::CircleRuleProto* mutable_circle();
+  inline ::CircleRuleProto* release_circle();
+
+  // optional .PathTextRuleProto path_text = 7;
+  inline bool has_path_text() const;
+  inline void clear_path_text();
+  static const int kPathTextFieldNumber = 7;
+  inline const ::PathTextRuleProto& path_text() const;
+  inline ::PathTextRuleProto* mutable_path_text();
+  inline ::PathTextRuleProto* release_path_text();
+
+  // @@protoc_insertion_point(class_scope:DrawElementProto)
+ private:
+  inline void set_has_scale();
+  inline void clear_has_scale();
+  inline void set_has_area();
+  inline void clear_has_area();
+  inline void set_has_symbol();
+  inline void clear_has_symbol();
+  inline void set_has_caption();
+  inline void clear_has_caption();
+  inline void set_has_circle();
+  inline void clear_has_circle();
+  inline void set_has_path_text();
+  inline void clear_has_path_text();
+
+  ::google::protobuf::RepeatedPtrField< ::LineRuleProto > lines_;
+  ::AreaRuleProto* area_;
+  ::SymbolRuleProto* symbol_;
+  ::CaptionRuleProto* caption_;
+  ::CircleRuleProto* circle_;
+  ::PathTextRuleProto* path_text_;
+  ::google::protobuf::int32 scale_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];
+
+  friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
+  friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
+  friend void protobuf_ShutdownFile_drules_5fstruct_2eproto();
+
+  void InitAsDefaultInstance();
+  static DrawElementProto* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ClassifElementProto : public ::google::protobuf::MessageLite {
+ public:
+  ClassifElementProto();
+  virtual ~ClassifElementProto();
+
+  ClassifElementProto(const ClassifElementProto& from);
+
+  inline ClassifElementProto& operator=(const ClassifElementProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  static const ClassifElementProto& default_instance();
+
+  void Swap(ClassifElementProto* other);
+
+  // implements Message ----------------------------------------------
+
+  ClassifElementProto* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ClassifElementProto& from);
+  void MergeFrom(const ClassifElementProto& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required string name = 1;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 1;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+
+  // repeated .DrawElementProto element = 2;
+  inline int element_size() const;
+  inline void clear_element();
+  static const int kElementFieldNumber = 2;
+  inline const ::DrawElementProto& element(int index) const;
+  inline ::DrawElementProto* mutable_element(int index);
+  inline ::DrawElementProto* add_element();
+  inline const ::google::protobuf::RepeatedPtrField< ::DrawElementProto >&
+      element() const;
+  inline ::google::protobuf::RepeatedPtrField< ::DrawElementProto >*
+      mutable_element();
+
+  // @@protoc_insertion_point(class_scope:ClassifElementProto)
+ private:
+  inline void set_has_name();
+  inline void clear_has_name();
+
+  ::std::string* name_;
+  ::google::protobuf::RepeatedPtrField< ::DrawElementProto > element_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
+
+  friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
+  friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
+  friend void protobuf_ShutdownFile_drules_5fstruct_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClassifElementProto* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class ContainerProto : public ::google::protobuf::MessageLite {
+ public:
+  ContainerProto();
+  virtual ~ContainerProto();
+
+  ContainerProto(const ContainerProto& from);
+
+  inline ContainerProto& operator=(const ContainerProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  static const ContainerProto& default_instance();
+
+  void Swap(ContainerProto* other);
+
+  // implements Message ----------------------------------------------
+
+  ContainerProto* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ContainerProto& from);
+  void MergeFrom(const ContainerProto& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .ClassifElementProto cont = 1;
+  inline int cont_size() const;
+  inline void clear_cont();
+  static const int kContFieldNumber = 1;
+  inline const ::ClassifElementProto& cont(int index) const;
+  inline ::ClassifElementProto* mutable_cont(int index);
+  inline ::ClassifElementProto* add_cont();
+  inline const ::google::protobuf::RepeatedPtrField< ::ClassifElementProto >&
+      cont() const;
+  inline ::google::protobuf::RepeatedPtrField< ::ClassifElementProto >*
+      mutable_cont();
+
+  // @@protoc_insertion_point(class_scope:ContainerProto)
+ private:
+
+  ::google::protobuf::RepeatedPtrField< ::ClassifElementProto > cont_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
+
+  friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
+  friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
+  friend void protobuf_ShutdownFile_drules_5fstruct_2eproto();
+
+  void InitAsDefaultInstance();
+  static ContainerProto* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+// DashDotProto
+
+// repeated double dd = 1;
+inline int DashDotProto::dd_size() const {
+  return dd_.size();
+}
+inline void DashDotProto::clear_dd() {
+  dd_.Clear();
+}
+inline double DashDotProto::dd(int index) const {
+  return dd_.Get(index);
+}
+inline void DashDotProto::set_dd(int index, double value) {
+  dd_.Set(index, value);
+}
+inline void DashDotProto::add_dd(double value) {
+  dd_.Add(value);
+}
+inline const ::google::protobuf::RepeatedField< double >&
+DashDotProto::dd() const {
+  return dd_;
+}
+inline ::google::protobuf::RepeatedField< double >*
+DashDotProto::mutable_dd() {
+  return &dd_;
+}
+
+// optional double offset = 2;
+inline bool DashDotProto::has_offset() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void DashDotProto::set_has_offset() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void DashDotProto::clear_has_offset() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void DashDotProto::clear_offset() {
+  offset_ = 0;
+  clear_has_offset();
+}
+inline double DashDotProto::offset() const {
+  return offset_;
+}
+inline void DashDotProto::set_offset(double value) {
+  set_has_offset();
+  offset_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// LineRuleProto
+
+// required double width = 1;
+inline bool LineRuleProto::has_width() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void LineRuleProto::set_has_width() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void LineRuleProto::clear_has_width() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void LineRuleProto::clear_width() {
+  width_ = 0;
+  clear_has_width();
+}
+inline double LineRuleProto::width() const {
+  return width_;
+}
+inline void LineRuleProto::set_width(double value) {
+  set_has_width();
+  width_ = value;
+}
+
+// required uint32 color = 2;
+inline bool LineRuleProto::has_color() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void LineRuleProto::set_has_color() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void LineRuleProto::clear_has_color() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void LineRuleProto::clear_color() {
+  color_ = 0u;
+  clear_has_color();
+}
+inline ::google::protobuf::uint32 LineRuleProto::color() const {
+  return color_;
+}
+inline void LineRuleProto::set_color(::google::protobuf::uint32 value) {
+  set_has_color();
+  color_ = value;
+}
+
+// optional .DashDotProto dashdot = 3;
+inline bool LineRuleProto::has_dashdot() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void LineRuleProto::set_has_dashdot() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void LineRuleProto::clear_has_dashdot() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void LineRuleProto::clear_dashdot() {
+  if (dashdot_ != NULL) dashdot_->::DashDotProto::Clear();
+  clear_has_dashdot();
+}
+inline const ::DashDotProto& LineRuleProto::dashdot() const {
+  return dashdot_ != NULL ? *dashdot_ : *default_instance_->dashdot_;
+}
+inline ::DashDotProto* LineRuleProto::mutable_dashdot() {
+  set_has_dashdot();
+  if (dashdot_ == NULL) dashdot_ = new ::DashDotProto;
+  return dashdot_;
+}
+inline ::DashDotProto* LineRuleProto::release_dashdot() {
+  clear_has_dashdot();
+  ::DashDotProto* temp = dashdot_;
+  dashdot_ = NULL;
+  return temp;
+}
+
+// required int32 priority = 4;
+inline bool LineRuleProto::has_priority() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void LineRuleProto::set_has_priority() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void LineRuleProto::clear_has_priority() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void LineRuleProto::clear_priority() {
+  priority_ = 0;
+  clear_has_priority();
+}
+inline ::google::protobuf::int32 LineRuleProto::priority() const {
+  return priority_;
+}
+inline void LineRuleProto::set_priority(::google::protobuf::int32 value) {
+  set_has_priority();
+  priority_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// LineDefProto
+
+// required double width = 1;
+inline bool LineDefProto::has_width() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void LineDefProto::set_has_width() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void LineDefProto::clear_has_width() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void LineDefProto::clear_width() {
+  width_ = 0;
+  clear_has_width();
+}
+inline double LineDefProto::width() const {
+  return width_;
+}
+inline void LineDefProto::set_width(double value) {
+  set_has_width();
+  width_ = value;
+}
+
+// required uint32 color = 2;
+inline bool LineDefProto::has_color() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void LineDefProto::set_has_color() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void LineDefProto::clear_has_color() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void LineDefProto::clear_color() {
+  color_ = 0u;
+  clear_has_color();
+}
+inline ::google::protobuf::uint32 LineDefProto::color() const {
+  return color_;
+}
+inline void LineDefProto::set_color(::google::protobuf::uint32 value) {
+  set_has_color();
+  color_ = value;
+}
+
+// optional .DashDotProto dashdot = 3;
+inline bool LineDefProto::has_dashdot() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void LineDefProto::set_has_dashdot() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void LineDefProto::clear_has_dashdot() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void LineDefProto::clear_dashdot() {
+  if (dashdot_ != NULL) dashdot_->::DashDotProto::Clear();
+  clear_has_dashdot();
+}
+inline const ::DashDotProto& LineDefProto::dashdot() const {
+  return dashdot_ != NULL ? *dashdot_ : *default_instance_->dashdot_;
+}
+inline ::DashDotProto* LineDefProto::mutable_dashdot() {
+  set_has_dashdot();
+  if (dashdot_ == NULL) dashdot_ = new ::DashDotProto;
+  return dashdot_;
+}
+inline ::DashDotProto* LineDefProto::release_dashdot() {
+  clear_has_dashdot();
+  ::DashDotProto* temp = dashdot_;
+  dashdot_ = NULL;
+  return temp;
+}
+
+// -------------------------------------------------------------------
+
+// AreaRuleProto
+
+// required uint32 color = 1;
+inline bool AreaRuleProto::has_color() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AreaRuleProto::set_has_color() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AreaRuleProto::clear_has_color() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AreaRuleProto::clear_color() {
+  color_ = 0u;
+  clear_has_color();
+}
+inline ::google::protobuf::uint32 AreaRuleProto::color() const {
+  return color_;
+}
+inline void AreaRuleProto::set_color(::google::protobuf::uint32 value) {
+  set_has_color();
+  color_ = value;
+}
+
+// optional .LineDefProto border = 2;
+inline bool AreaRuleProto::has_border() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AreaRuleProto::set_has_border() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AreaRuleProto::clear_has_border() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AreaRuleProto::clear_border() {
+  if (border_ != NULL) border_->::LineDefProto::Clear();
+  clear_has_border();
+}
+inline const ::LineDefProto& AreaRuleProto::border() const {
+  return border_ != NULL ? *border_ : *default_instance_->border_;
+}
+inline ::LineDefProto* AreaRuleProto::mutable_border() {
+  set_has_border();
+  if (border_ == NULL) border_ = new ::LineDefProto;
+  return border_;
+}
+inline ::LineDefProto* AreaRuleProto::release_border() {
+  clear_has_border();
+  ::LineDefProto* temp = border_;
+  border_ = NULL;
+  return temp;
+}
+
+// required int32 priority = 3;
+inline bool AreaRuleProto::has_priority() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void AreaRuleProto::set_has_priority() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void AreaRuleProto::clear_has_priority() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void AreaRuleProto::clear_priority() {
+  priority_ = 0;
+  clear_has_priority();
+}
+inline ::google::protobuf::int32 AreaRuleProto::priority() const {
+  return priority_;
+}
+inline void AreaRuleProto::set_priority(::google::protobuf::int32 value) {
+  set_has_priority();
+  priority_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// SymbolRuleProto
+
+// required string name = 1;
+inline bool SymbolRuleProto::has_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SymbolRuleProto::set_has_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SymbolRuleProto::clear_has_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SymbolRuleProto::clear_name() {
+  if (name_ != &::google::protobuf::internal::kEmptyString) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& SymbolRuleProto::name() const {
+  return *name_;
+}
+inline void SymbolRuleProto::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+}
+inline void SymbolRuleProto::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+}
+inline void SymbolRuleProto::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* SymbolRuleProto::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  return name_;
+}
+inline ::std::string* SymbolRuleProto::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+
+// optional int32 apply_for_type = 2;
+inline bool SymbolRuleProto::has_apply_for_type() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SymbolRuleProto::set_has_apply_for_type() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SymbolRuleProto::clear_has_apply_for_type() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SymbolRuleProto::clear_apply_for_type() {
+  apply_for_type_ = 0;
+  clear_has_apply_for_type();
+}
+inline ::google::protobuf::int32 SymbolRuleProto::apply_for_type() const {
+  return apply_for_type_;
+}
+inline void SymbolRuleProto::set_apply_for_type(::google::protobuf::int32 value) {
+  set_has_apply_for_type();
+  apply_for_type_ = value;
+}
+
+// required int32 priority = 3;
+inline bool SymbolRuleProto::has_priority() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SymbolRuleProto::set_has_priority() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SymbolRuleProto::clear_has_priority() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SymbolRuleProto::clear_priority() {
+  priority_ = 0;
+  clear_has_priority();
+}
+inline ::google::protobuf::int32 SymbolRuleProto::priority() const {
+  return priority_;
+}
+inline void SymbolRuleProto::set_priority(::google::protobuf::int32 value) {
+  set_has_priority();
+  priority_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// CaptionDefProto
+
+// required int32 height = 1;
+inline bool CaptionDefProto::has_height() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void CaptionDefProto::set_has_height() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void CaptionDefProto::clear_has_height() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void CaptionDefProto::clear_height() {
+  height_ = 0;
+  clear_has_height();
+}
+inline ::google::protobuf::int32 CaptionDefProto::height() const {
+  return height_;
+}
+inline void CaptionDefProto::set_height(::google::protobuf::int32 value) {
+  set_has_height();
+  height_ = value;
+}
+
+// required uint32 color = 2;
+inline bool CaptionDefProto::has_color() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void CaptionDefProto::set_has_color() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void CaptionDefProto::clear_has_color() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void CaptionDefProto::clear_color() {
+  color_ = 0u;
+  clear_has_color();
+}
+inline ::google::protobuf::uint32 CaptionDefProto::color() const {
+  return color_;
+}
+inline void CaptionDefProto::set_color(::google::protobuf::uint32 value) {
+  set_has_color();
+  color_ = value;
+}
+
+// optional uint32 stroke_color = 3;
+inline bool CaptionDefProto::has_stroke_color() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void CaptionDefProto::set_has_stroke_color() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void CaptionDefProto::clear_has_stroke_color() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void CaptionDefProto::clear_stroke_color() {
+  stroke_color_ = 0u;
+  clear_has_stroke_color();
+}
+inline ::google::protobuf::uint32 CaptionDefProto::stroke_color() const {
+  return stroke_color_;
+}
+inline void CaptionDefProto::set_stroke_color(::google::protobuf::uint32 value) {
+  set_has_stroke_color();
+  stroke_color_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// CaptionRuleProto
+
+// required .CaptionDefProto primary = 1;
+inline bool CaptionRuleProto::has_primary() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void CaptionRuleProto::set_has_primary() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void CaptionRuleProto::clear_has_primary() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void CaptionRuleProto::clear_primary() {
+  if (primary_ != NULL) primary_->::CaptionDefProto::Clear();
+  clear_has_primary();
+}
+inline const ::CaptionDefProto& CaptionRuleProto::primary() const {
+  return primary_ != NULL ? *primary_ : *default_instance_->primary_;
+}
+inline ::CaptionDefProto* CaptionRuleProto::mutable_primary() {
+  set_has_primary();
+  if (primary_ == NULL) primary_ = new ::CaptionDefProto;
+  return primary_;
+}
+inline ::CaptionDefProto* CaptionRuleProto::release_primary() {
+  clear_has_primary();
+  ::CaptionDefProto* temp = primary_;
+  primary_ = NULL;
+  return temp;
+}
+
+// optional .CaptionDefProto secondary = 2;
+inline bool CaptionRuleProto::has_secondary() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void CaptionRuleProto::set_has_secondary() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void CaptionRuleProto::clear_has_secondary() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void CaptionRuleProto::clear_secondary() {
+  if (secondary_ != NULL) secondary_->::CaptionDefProto::Clear();
+  clear_has_secondary();
+}
+inline const ::CaptionDefProto& CaptionRuleProto::secondary() const {
+  return secondary_ != NULL ? *secondary_ : *default_instance_->secondary_;
+}
+inline ::CaptionDefProto* CaptionRuleProto::mutable_secondary() {
+  set_has_secondary();
+  if (secondary_ == NULL) secondary_ = new ::CaptionDefProto;
+  return secondary_;
+}
+inline ::CaptionDefProto* CaptionRuleProto::release_secondary() {
+  clear_has_secondary();
+  ::CaptionDefProto* temp = secondary_;
+  secondary_ = NULL;
+  return temp;
+}
+
+// required int32 priority = 3;
+inline bool CaptionRuleProto::has_priority() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void CaptionRuleProto::set_has_priority() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void CaptionRuleProto::clear_has_priority() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void CaptionRuleProto::clear_priority() {
+  priority_ = 0;
+  clear_has_priority();
+}
+inline ::google::protobuf::int32 CaptionRuleProto::priority() const {
+  return priority_;
+}
+inline void CaptionRuleProto::set_priority(::google::protobuf::int32 value) {
+  set_has_priority();
+  priority_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// CircleRuleProto
+
+// required double radius = 1;
+inline bool CircleRuleProto::has_radius() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void CircleRuleProto::set_has_radius() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void CircleRuleProto::clear_has_radius() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void CircleRuleProto::clear_radius() {
+  radius_ = 0;
+  clear_has_radius();
+}
+inline double CircleRuleProto::radius() const {
+  return radius_;
+}
+inline void CircleRuleProto::set_radius(double value) {
+  set_has_radius();
+  radius_ = value;
+}
+
+// required uint32 color = 2;
+inline bool CircleRuleProto::has_color() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void CircleRuleProto::set_has_color() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void CircleRuleProto::clear_has_color() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void CircleRuleProto::clear_color() {
+  color_ = 0u;
+  clear_has_color();
+}
+inline ::google::protobuf::uint32 CircleRuleProto::color() const {
+  return color_;
+}
+inline void CircleRuleProto::set_color(::google::protobuf::uint32 value) {
+  set_has_color();
+  color_ = value;
+}
+
+// optional .LineDefProto border = 3;
+inline bool CircleRuleProto::has_border() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void CircleRuleProto::set_has_border() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void CircleRuleProto::clear_has_border() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void CircleRuleProto::clear_border() {
+  if (border_ != NULL) border_->::LineDefProto::Clear();
+  clear_has_border();
+}
+inline const ::LineDefProto& CircleRuleProto::border() const {
+  return border_ != NULL ? *border_ : *default_instance_->border_;
+}
+inline ::LineDefProto* CircleRuleProto::mutable_border() {
+  set_has_border();
+  if (border_ == NULL) border_ = new ::LineDefProto;
+  return border_;
+}
+inline ::LineDefProto* CircleRuleProto::release_border() {
+  clear_has_border();
+  ::LineDefProto* temp = border_;
+  border_ = NULL;
+  return temp;
+}
+
+// required int32 priority = 4;
+inline bool CircleRuleProto::has_priority() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void CircleRuleProto::set_has_priority() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void CircleRuleProto::clear_has_priority() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void CircleRuleProto::clear_priority() {
+  priority_ = 0;
+  clear_has_priority();
+}
+inline ::google::protobuf::int32 CircleRuleProto::priority() const {
+  return priority_;
+}
+inline void CircleRuleProto::set_priority(::google::protobuf::int32 value) {
+  set_has_priority();
+  priority_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// PathTextRuleProto
+
+// required .CaptionDefProto primary = 1;
+inline bool PathTextRuleProto::has_primary() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void PathTextRuleProto::set_has_primary() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void PathTextRuleProto::clear_has_primary() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void PathTextRuleProto::clear_primary() {
+  if (primary_ != NULL) primary_->::CaptionDefProto::Clear();
+  clear_has_primary();
+}
+inline const ::CaptionDefProto& PathTextRuleProto::primary() const {
+  return primary_ != NULL ? *primary_ : *default_instance_->primary_;
+}
+inline ::CaptionDefProto* PathTextRuleProto::mutable_primary() {
+  set_has_primary();
+  if (primary_ == NULL) primary_ = new ::CaptionDefProto;
+  return primary_;
+}
+inline ::CaptionDefProto* PathTextRuleProto::release_primary() {
+  clear_has_primary();
+  ::CaptionDefProto* temp = primary_;
+  primary_ = NULL;
+  return temp;
+}
+
+// optional .CaptionDefProto secondary = 2;
+inline bool PathTextRuleProto::has_secondary() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void PathTextRuleProto::set_has_secondary() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void PathTextRuleProto::clear_has_secondary() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void PathTextRuleProto::clear_secondary() {
+  if (secondary_ != NULL) secondary_->::CaptionDefProto::Clear();
+  clear_has_secondary();
+}
+inline const ::CaptionDefProto& PathTextRuleProto::secondary() const {
+  return secondary_ != NULL ? *secondary_ : *default_instance_->secondary_;
+}
+inline ::CaptionDefProto* PathTextRuleProto::mutable_secondary() {
+  set_has_secondary();
+  if (secondary_ == NULL) secondary_ = new ::CaptionDefProto;
+  return secondary_;
+}
+inline ::CaptionDefProto* PathTextRuleProto::release_secondary() {
+  clear_has_secondary();
+  ::CaptionDefProto* temp = secondary_;
+  secondary_ = NULL;
+  return temp;
+}
+
+// required int32 priority = 3;
+inline bool PathTextRuleProto::has_priority() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void PathTextRuleProto::set_has_priority() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void PathTextRuleProto::clear_has_priority() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void PathTextRuleProto::clear_priority() {
+  priority_ = 0;
+  clear_has_priority();
+}
+inline ::google::protobuf::int32 PathTextRuleProto::priority() const {
+  return priority_;
+}
+inline void PathTextRuleProto::set_priority(::google::protobuf::int32 value) {
+  set_has_priority();
+  priority_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// DrawElementProto
+
+// required int32 scale = 1;
+inline bool DrawElementProto::has_scale() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void DrawElementProto::set_has_scale() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void DrawElementProto::clear_has_scale() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void DrawElementProto::clear_scale() {
+  scale_ = 0;
+  clear_has_scale();
+}
+inline ::google::protobuf::int32 DrawElementProto::scale() const {
+  return scale_;
+}
+inline void DrawElementProto::set_scale(::google::protobuf::int32 value) {
+  set_has_scale();
+  scale_ = value;
+}
+
+// repeated .LineRuleProto lines = 2;
+inline int DrawElementProto::lines_size() const {
+  return lines_.size();
+}
+inline void DrawElementProto::clear_lines() {
+  lines_.Clear();
+}
+inline const ::LineRuleProto& DrawElementProto::lines(int index) const {
+  return lines_.Get(index);
+}
+inline ::LineRuleProto* DrawElementProto::mutable_lines(int index) {
+  return lines_.Mutable(index);
+}
+inline ::LineRuleProto* DrawElementProto::add_lines() {
+  return lines_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::LineRuleProto >&
+DrawElementProto::lines() const {
+  return lines_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::LineRuleProto >*
+DrawElementProto::mutable_lines() {
+  return &lines_;
+}
+
+// optional .AreaRuleProto area = 3;
+inline bool DrawElementProto::has_area() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void DrawElementProto::set_has_area() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void DrawElementProto::clear_has_area() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void DrawElementProto::clear_area() {
+  if (area_ != NULL) area_->::AreaRuleProto::Clear();
+  clear_has_area();
+}
+inline const ::AreaRuleProto& DrawElementProto::area() const {
+  return area_ != NULL ? *area_ : *default_instance_->area_;
+}
+inline ::AreaRuleProto* DrawElementProto::mutable_area() {
+  set_has_area();
+  if (area_ == NULL) area_ = new ::AreaRuleProto;
+  return area_;
+}
+inline ::AreaRuleProto* DrawElementProto::release_area() {
+  clear_has_area();
+  ::AreaRuleProto* temp = area_;
+  area_ = NULL;
+  return temp;
+}
+
+// optional .SymbolRuleProto symbol = 4;
+inline bool DrawElementProto::has_symbol() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void DrawElementProto::set_has_symbol() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void DrawElementProto::clear_has_symbol() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void DrawElementProto::clear_symbol() {
+  if (symbol_ != NULL) symbol_->::SymbolRuleProto::Clear();
+  clear_has_symbol();
+}
+inline const ::SymbolRuleProto& DrawElementProto::symbol() const {
+  return symbol_ != NULL ? *symbol_ : *default_instance_->symbol_;
+}
+inline ::SymbolRuleProto* DrawElementProto::mutable_symbol() {
+  set_has_symbol();
+  if (symbol_ == NULL) symbol_ = new ::SymbolRuleProto;
+  return symbol_;
+}
+inline ::SymbolRuleProto* DrawElementProto::release_symbol() {
+  clear_has_symbol();
+  ::SymbolRuleProto* temp = symbol_;
+  symbol_ = NULL;
+  return temp;
+}
+
+// optional .CaptionRuleProto caption = 5;
+inline bool DrawElementProto::has_caption() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void DrawElementProto::set_has_caption() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void DrawElementProto::clear_has_caption() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void DrawElementProto::clear_caption() {
+  if (caption_ != NULL) caption_->::CaptionRuleProto::Clear();
+  clear_has_caption();
+}
+inline const ::CaptionRuleProto& DrawElementProto::caption() const {
+  return caption_ != NULL ? *caption_ : *default_instance_->caption_;
+}
+inline ::CaptionRuleProto* DrawElementProto::mutable_caption() {
+  set_has_caption();
+  if (caption_ == NULL) caption_ = new ::CaptionRuleProto;
+  return caption_;
+}
+inline ::CaptionRuleProto* DrawElementProto::release_caption() {
+  clear_has_caption();
+  ::CaptionRuleProto* temp = caption_;
+  caption_ = NULL;
+  return temp;
+}
+
+// optional .CircleRuleProto circle = 6;
+inline bool DrawElementProto::has_circle() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void DrawElementProto::set_has_circle() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void DrawElementProto::clear_has_circle() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void DrawElementProto::clear_circle() {
+  if (circle_ != NULL) circle_->::CircleRuleProto::Clear();
+  clear_has_circle();
+}
+inline const ::CircleRuleProto& DrawElementProto::circle() const {
+  return circle_ != NULL ? *circle_ : *default_instance_->circle_;
+}
+inline ::CircleRuleProto* DrawElementProto::mutable_circle() {
+  set_has_circle();
+  if (circle_ == NULL) circle_ = new ::CircleRuleProto;
+  return circle_;
+}
+inline ::CircleRuleProto* DrawElementProto::release_circle() {
+  clear_has_circle();
+  ::CircleRuleProto* temp = circle_;
+  circle_ = NULL;
+  return temp;
+}
+
+// optional .PathTextRuleProto path_text = 7;
+inline bool DrawElementProto::has_path_text() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void DrawElementProto::set_has_path_text() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void DrawElementProto::clear_has_path_text() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void DrawElementProto::clear_path_text() {
+  if (path_text_ != NULL) path_text_->::PathTextRuleProto::Clear();
+  clear_has_path_text();
+}
+inline const ::PathTextRuleProto& DrawElementProto::path_text() const {
+  return path_text_ != NULL ? *path_text_ : *default_instance_->path_text_;
+}
+inline ::PathTextRuleProto* DrawElementProto::mutable_path_text() {
+  set_has_path_text();
+  if (path_text_ == NULL) path_text_ = new ::PathTextRuleProto;
+  return path_text_;
+}
+inline ::PathTextRuleProto* DrawElementProto::release_path_text() {
+  clear_has_path_text();
+  ::PathTextRuleProto* temp = path_text_;
+  path_text_ = NULL;
+  return temp;
+}
+
+// -------------------------------------------------------------------
+
+// ClassifElementProto
+
+// required string name = 1;
+inline bool ClassifElementProto::has_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClassifElementProto::set_has_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClassifElementProto::clear_has_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClassifElementProto::clear_name() {
+  if (name_ != &::google::protobuf::internal::kEmptyString) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& ClassifElementProto::name() const {
+  return *name_;
+}
+inline void ClassifElementProto::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+}
+inline void ClassifElementProto::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+}
+inline void ClassifElementProto::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ClassifElementProto::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    name_ = new ::std::string;
+  }
+  return name_;
+}
+inline ::std::string* ClassifElementProto::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+
+// repeated .DrawElementProto element = 2;
+inline int ClassifElementProto::element_size() const {
+  return element_.size();
+}
+inline void ClassifElementProto::clear_element() {
+  element_.Clear();
+}
+inline const ::DrawElementProto& ClassifElementProto::element(int index) const {
+  return element_.Get(index);
+}
+inline ::DrawElementProto* ClassifElementProto::mutable_element(int index) {
+  return element_.Mutable(index);
+}
+inline ::DrawElementProto* ClassifElementProto::add_element() {
+  return element_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::DrawElementProto >&
+ClassifElementProto::element() const {
+  return element_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::DrawElementProto >*
+ClassifElementProto::mutable_element() {
+  return &element_;
+}
+
+// -------------------------------------------------------------------
+
+// ContainerProto
+
+// repeated .ClassifElementProto cont = 1;
+inline int ContainerProto::cont_size() const {
+  return cont_.size();
+}
+inline void ContainerProto::clear_cont() {
+  cont_.Clear();
+}
+inline const ::ClassifElementProto& ContainerProto::cont(int index) const {
+  return cont_.Get(index);
+}
+inline ::ClassifElementProto* ContainerProto::mutable_cont(int index) {
+  return cont_.Mutable(index);
+}
+inline ::ClassifElementProto* ContainerProto::add_cont() {
+  return cont_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::ClassifElementProto >&
+ContainerProto::cont() const {
+  return cont_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::ClassifElementProto >*
+ContainerProto::mutable_cont() {
+  return &cont_;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_drules_5fstruct_2eproto__INCLUDED