// Generated by the protocol buffer compiler.  DO NOT EDIT!

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "drules_struct_lite.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 DashDotProto::default_instance_;
  delete PathSymProto::default_instance_;
  delete LineRuleProto::default_instance_;
  delete LineDefProto::default_instance_;
  delete AreaRuleProto::default_instance_;
  delete SymbolRuleProto::default_instance_;
  delete CaptionDefProto::default_instance_;
  delete CaptionRuleProto::default_instance_;
  delete CircleRuleProto::default_instance_;
  delete PathTextRuleProto::default_instance_;
  delete DrawElementProto::default_instance_;
  delete ClassifElementProto::default_instance_;
  delete ContainerProto::default_instance_;
}

void protobuf_AddDesc_drules_5fstruct_2eproto() {
  static bool already_here = false;
  if (already_here) return;
  already_here = true;
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  DashDotProto::default_instance_ = new DashDotProto();
  PathSymProto::default_instance_ = new PathSymProto();
  LineRuleProto::default_instance_ = new LineRuleProto();
  LineDefProto::default_instance_ = new LineDefProto();
  AreaRuleProto::default_instance_ = new AreaRuleProto();
  SymbolRuleProto::default_instance_ = new SymbolRuleProto();
  CaptionDefProto::default_instance_ = new CaptionDefProto();
  CaptionRuleProto::default_instance_ = new CaptionRuleProto();
  CircleRuleProto::default_instance_ = new CircleRuleProto();
  PathTextRuleProto::default_instance_ = new PathTextRuleProto();
  DrawElementProto::default_instance_ = new DrawElementProto();
  ClassifElementProto::default_instance_ = new ClassifElementProto();
  ContainerProto::default_instance_ = new ContainerProto();
  DashDotProto::default_instance_->InitAsDefaultInstance();
  PathSymProto::default_instance_->InitAsDefaultInstance();
  LineRuleProto::default_instance_->InitAsDefaultInstance();
  LineDefProto::default_instance_->InitAsDefaultInstance();
  AreaRuleProto::default_instance_->InitAsDefaultInstance();
  SymbolRuleProto::default_instance_->InitAsDefaultInstance();
  CaptionDefProto::default_instance_->InitAsDefaultInstance();
  CaptionRuleProto::default_instance_->InitAsDefaultInstance();
  CircleRuleProto::default_instance_->InitAsDefaultInstance();
  PathTextRuleProto::default_instance_->InitAsDefaultInstance();
  DrawElementProto::default_instance_->InitAsDefaultInstance();
  ClassifElementProto::default_instance_->InitAsDefaultInstance();
  ContainerProto::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_drules_5fstruct_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_drules_5fstruct_2eproto {
  StaticDescriptorInitializer_drules_5fstruct_2eproto() {
    protobuf_AddDesc_drules_5fstruct_2eproto();
  }
} static_descriptor_initializer_drules_5fstruct_2eproto_;

bool LineJoin_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

bool LineCap_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}


// ===================================================================

#ifndef _MSC_VER
const int DashDotProto::kDdFieldNumber;
const int DashDotProto::kOffsetFieldNumber;
#endif  // !_MSC_VER

DashDotProto::DashDotProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
}

void DashDotProto::InitAsDefaultInstance() {
}

DashDotProto::DashDotProto(const DashDotProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
}

void DashDotProto::SharedCtor() {
  _cached_size_ = 0;
  offset_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

DashDotProto::~DashDotProto() {
  SharedDtor();
}

void DashDotProto::SharedDtor() {
  if (this != default_instance_) {
  }
}

void DashDotProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const DashDotProto& DashDotProto::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
}

DashDotProto* DashDotProto::default_instance_ = NULL;

DashDotProto* DashDotProto::New() const {
  return new DashDotProto;
}

void DashDotProto::Clear() {
  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
    offset_ = 0;
  }
  dd_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

bool DashDotProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated double dd = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_dd:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 1, 9, input, this->mutable_dd())));
        } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
                   == ::google::protobuf::internal::WireFormatLite::
                      WIRETYPE_LENGTH_DELIMITED) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, this->mutable_dd())));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(9)) goto parse_dd;
        if (input->ExpectTag(17)) goto parse_offset;
        break;
      }
      
      // optional double offset = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_offset:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &offset_)));
          set_has_offset();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void DashDotProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // repeated double dd = 1;
  for (int i = 0; i < this->dd_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(
      1, this->dd(i), output);
  }
  
  // optional double offset = 2;
  if (has_offset()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->offset(), output);
  }
  
}

int DashDotProto::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
    // optional double offset = 2;
    if (has_offset()) {
      total_size += 1 + 8;
    }
    
  }
  // repeated double dd = 1;
  {
    int data_size = 0;
    data_size = 8 * this->dd_size();
    total_size += 1 * this->dd_size() + data_size;
  }
  
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DashDotProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const DashDotProto*>(&from));
}

void DashDotProto::MergeFrom(const DashDotProto& from) {
  GOOGLE_CHECK_NE(&from, this);
  dd_.MergeFrom(from.dd_);
  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
    if (from.has_offset()) {
      set_offset(from.offset());
    }
  }
}

void DashDotProto::CopyFrom(const DashDotProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DashDotProto::IsInitialized() const {
  
  return true;
}

void DashDotProto::Swap(DashDotProto* other) {
  if (other != this) {
    dd_.Swap(&other->dd_);
    std::swap(offset_, other->offset_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string DashDotProto::GetTypeName() const {
  return "DashDotProto";
}


// ===================================================================

#ifndef _MSC_VER
const int PathSymProto::kNameFieldNumber;
const int PathSymProto::kStepFieldNumber;
const int PathSymProto::kOffsetFieldNumber;
#endif  // !_MSC_VER

PathSymProto::PathSymProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
}

void PathSymProto::InitAsDefaultInstance() {
}

PathSymProto::PathSymProto(const PathSymProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
}

void PathSymProto::SharedCtor() {
  _cached_size_ = 0;
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  step_ = 0;
  offset_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

PathSymProto::~PathSymProto() {
  SharedDtor();
}

void PathSymProto::SharedDtor() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    delete name_;
  }
  if (this != default_instance_) {
  }
}

void PathSymProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const PathSymProto& PathSymProto::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
}

PathSymProto* PathSymProto::default_instance_ = NULL;

PathSymProto* PathSymProto::New() const {
  return new PathSymProto;
}

void PathSymProto::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::kEmptyString) {
        name_->clear();
      }
    }
    step_ = 0;
    offset_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

bool PathSymProto::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(17)) goto parse_step;
        break;
      }
      
      // required double step = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_step:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &step_)));
          set_has_step();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(25)) goto parse_offset;
        break;
      }
      
      // optional double offset = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_offset:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &offset_)));
          set_has_offset();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void PathSymProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->name(), output);
  }
  
  // required double step = 2;
  if (has_step()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->step(), output);
  }
  
  // optional double offset = 3;
  if (has_offset()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(3, this->offset(), output);
  }
  
}

int PathSymProto::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());
    }
    
    // required double step = 2;
    if (has_step()) {
      total_size += 1 + 8;
    }
    
    // optional double offset = 3;
    if (has_offset()) {
      total_size += 1 + 8;
    }
    
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PathSymProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const PathSymProto*>(&from));
}

void PathSymProto::MergeFrom(const PathSymProto& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_name()) {
      set_name(from.name());
    }
    if (from.has_step()) {
      set_step(from.step());
    }
    if (from.has_offset()) {
      set_offset(from.offset());
    }
  }
}

void PathSymProto::CopyFrom(const PathSymProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PathSymProto::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
  
  return true;
}

void PathSymProto::Swap(PathSymProto* other) {
  if (other != this) {
    std::swap(name_, other->name_);
    std::swap(step_, other->step_);
    std::swap(offset_, other->offset_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string PathSymProto::GetTypeName() const {
  return "PathSymProto";
}


// ===================================================================

#ifndef _MSC_VER
const int LineRuleProto::kWidthFieldNumber;
const int LineRuleProto::kColorFieldNumber;
const int LineRuleProto::kDashdotFieldNumber;
const int LineRuleProto::kPriorityFieldNumber;
const int LineRuleProto::kPathsymFieldNumber;
const int LineRuleProto::kJoinFieldNumber;
const int LineRuleProto::kCapFieldNumber;
#endif  // !_MSC_VER

LineRuleProto::LineRuleProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
}

void LineRuleProto::InitAsDefaultInstance() {
  dashdot_ = const_cast< ::DashDotProto*>(&::DashDotProto::default_instance());
  pathsym_ = const_cast< ::PathSymProto*>(&::PathSymProto::default_instance());
}

LineRuleProto::LineRuleProto(const LineRuleProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
}

void LineRuleProto::SharedCtor() {
  _cached_size_ = 0;
  width_ = 0;
  color_ = 0u;
  dashdot_ = NULL;
  priority_ = 0;
  pathsym_ = NULL;
  join_ = 0;
  cap_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

LineRuleProto::~LineRuleProto() {
  SharedDtor();
}

void LineRuleProto::SharedDtor() {
  if (this != default_instance_) {
    delete dashdot_;
    delete pathsym_;
  }
}

void LineRuleProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const LineRuleProto& LineRuleProto::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
}

LineRuleProto* LineRuleProto::default_instance_ = NULL;

LineRuleProto* LineRuleProto::New() const {
  return new LineRuleProto;
}

void LineRuleProto::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    width_ = 0;
    color_ = 0u;
    if (has_dashdot()) {
      if (dashdot_ != NULL) dashdot_->::DashDotProto::Clear();
    }
    priority_ = 0;
    if (has_pathsym()) {
      if (pathsym_ != NULL) pathsym_->::PathSymProto::Clear();
    }
    join_ = 0;
    cap_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

bool LineRuleProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required double width = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &width_)));
          set_has_width();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_color;
        break;
      }
      
      // required uint32 color = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_color:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &color_)));
          set_has_color();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_dashdot;
        break;
      }
      
      // optional .DashDotProto dashdot = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_dashdot:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_dashdot()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_priority;
        break;
      }
      
      // required int32 priority = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_priority:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &priority_)));
          set_has_priority();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(42)) goto parse_pathsym;
        break;
      }
      
      // optional .PathSymProto pathsym = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_pathsym:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_pathsym()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_join;
        break;
      }
      
      // optional .LineJoin join = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_join:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (LineJoin_IsValid(value)) {
            set_join(static_cast< LineJoin >(value));
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(56)) goto parse_cap;
        break;
      }
      
      // optional .LineCap cap = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_cap:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (LineCap_IsValid(value)) {
            set_cap(static_cast< LineCap >(value));
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void LineRuleProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required double width = 1;
  if (has_width()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->width(), output);
  }
  
  // required uint32 color = 2;
  if (has_color()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->color(), output);
  }
  
  // optional .DashDotProto dashdot = 3;
  if (has_dashdot()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      3, this->dashdot(), output);
  }
  
  // required int32 priority = 4;
  if (has_priority()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->priority(), output);
  }
  
  // optional .PathSymProto pathsym = 5;
  if (has_pathsym()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      5, this->pathsym(), output);
  }
  
  // optional .LineJoin join = 6;
  if (has_join()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      6, this->join(), output);
  }
  
  // optional .LineCap cap = 7;
  if (has_cap()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      7, this->cap(), output);
  }
  
}

int LineRuleProto::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required double width = 1;
    if (has_width()) {
      total_size += 1 + 8;
    }
    
    // required uint32 color = 2;
    if (has_color()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->color());
    }
    
    // optional .DashDotProto dashdot = 3;
    if (has_dashdot()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->dashdot());
    }
    
    // required int32 priority = 4;
    if (has_priority()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->priority());
    }
    
    // optional .PathSymProto pathsym = 5;
    if (has_pathsym()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->pathsym());
    }
    
    // optional .LineJoin join = 6;
    if (has_join()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->join());
    }
    
    // optional .LineCap cap = 7;
    if (has_cap()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->cap());
    }
    
  }
  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()) {
      set_color(from.color());
    }
    if (from.has_dashdot()) {
      mutable_dashdot()->::DashDotProto::MergeFrom(from.dashdot());
    }
    if (from.has_priority()) {
      set_priority(from.priority());
    }
    if (from.has_pathsym()) {
      mutable_pathsym()->::PathSymProto::MergeFrom(from.pathsym());
    }
    if (from.has_join()) {
      set_join(from.join());
    }
    if (from.has_cap()) {
      set_cap(from.cap());
    }
  }
}

void LineRuleProto::CopyFrom(const LineRuleProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LineRuleProto::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000000b) != 0x0000000b) return false;
  
  if (has_pathsym()) {
    if (!this->pathsym().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(priority_, other->priority_);
    std::swap(pathsym_, other->pathsym_);
    std::swap(join_, other->join_);
    std::swap(cap_, other->cap_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string LineRuleProto::GetTypeName() const {
  return "LineRuleProto";
}


// ===================================================================

#ifndef _MSC_VER
const int LineDefProto::kWidthFieldNumber;
const int LineDefProto::kColorFieldNumber;
const int LineDefProto::kDashdotFieldNumber;
const int LineDefProto::kPathsymFieldNumber;
const int LineDefProto::kJoinFieldNumber;
const int LineDefProto::kCapFieldNumber;
#endif  // !_MSC_VER

LineDefProto::LineDefProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
}

void LineDefProto::InitAsDefaultInstance() {
  dashdot_ = const_cast< ::DashDotProto*>(&::DashDotProto::default_instance());
  pathsym_ = const_cast< ::PathSymProto*>(&::PathSymProto::default_instance());
}

LineDefProto::LineDefProto(const LineDefProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
}

void LineDefProto::SharedCtor() {
  _cached_size_ = 0;
  width_ = 0;
  color_ = 0u;
  dashdot_ = NULL;
  pathsym_ = NULL;
  join_ = 0;
  cap_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

LineDefProto::~LineDefProto() {
  SharedDtor();
}

void LineDefProto::SharedDtor() {
  if (this != default_instance_) {
    delete dashdot_;
    delete pathsym_;
  }
}

void LineDefProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const LineDefProto& LineDefProto::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
}

LineDefProto* LineDefProto::default_instance_ = NULL;

LineDefProto* LineDefProto::New() const {
  return new LineDefProto;
}

void LineDefProto::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    width_ = 0;
    color_ = 0u;
    if (has_dashdot()) {
      if (dashdot_ != NULL) dashdot_->::DashDotProto::Clear();
    }
    if (has_pathsym()) {
      if (pathsym_ != NULL) pathsym_->::PathSymProto::Clear();
    }
    join_ = 0;
    cap_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

bool LineDefProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required double width = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &width_)));
          set_has_width();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_color;
        break;
      }
      
      // required uint32 color = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_color:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &color_)));
          set_has_color();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_dashdot;
        break;
      }
      
      // optional .DashDotProto dashdot = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_dashdot:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_dashdot()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_pathsym;
        break;
      }
      
      // optional .PathSymProto pathsym = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_pathsym:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_pathsym()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_join;
        break;
      }
      
      // optional .LineJoin join = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_join:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (LineJoin_IsValid(value)) {
            set_join(static_cast< LineJoin >(value));
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(56)) goto parse_cap;
        break;
      }
      
      // optional .LineCap cap = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_cap:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (LineCap_IsValid(value)) {
            set_cap(static_cast< LineCap >(value));
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void LineDefProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required double width = 1;
  if (has_width()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->width(), output);
  }
  
  // required uint32 color = 2;
  if (has_color()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->color(), output);
  }
  
  // optional .DashDotProto dashdot = 3;
  if (has_dashdot()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      3, this->dashdot(), output);
  }
  
  // optional .PathSymProto pathsym = 4;
  if (has_pathsym()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      4, this->pathsym(), output);
  }
  
  // optional .LineJoin join = 6;
  if (has_join()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      6, this->join(), output);
  }
  
  // optional .LineCap cap = 7;
  if (has_cap()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      7, this->cap(), output);
  }
  
}

int LineDefProto::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required double width = 1;
    if (has_width()) {
      total_size += 1 + 8;
    }
    
    // required uint32 color = 2;
    if (has_color()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->color());
    }
    
    // optional .DashDotProto dashdot = 3;
    if (has_dashdot()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->dashdot());
    }
    
    // optional .PathSymProto pathsym = 4;
    if (has_pathsym()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->pathsym());
    }
    
    // optional .LineJoin join = 6;
    if (has_join()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->join());
    }
    
    // optional .LineCap cap = 7;
    if (has_cap()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->cap());
    }
    
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void LineDefProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const LineDefProto*>(&from));
}

void LineDefProto::MergeFrom(const LineDefProto& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_width()) {
      set_width(from.width());
    }
    if (from.has_color()) {
      set_color(from.color());
    }
    if (from.has_dashdot()) {
      mutable_dashdot()->::DashDotProto::MergeFrom(from.dashdot());
    }
    if (from.has_pathsym()) {
      mutable_pathsym()->::PathSymProto::MergeFrom(from.pathsym());
    }
    if (from.has_join()) {
      set_join(from.join());
    }
    if (from.has_cap()) {
      set_cap(from.cap());
    }
  }
}

void LineDefProto::CopyFrom(const LineDefProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LineDefProto::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
  
  if (has_pathsym()) {
    if (!this->pathsym().IsInitialized()) return false;
  }
  return true;
}

void LineDefProto::Swap(LineDefProto* other) {
  if (other != this) {
    std::swap(width_, other->width_);
    std::swap(color_, other->color_);
    std::swap(dashdot_, other->dashdot_);
    std::swap(pathsym_, other->pathsym_);
    std::swap(join_, other->join_);
    std::swap(cap_, other->cap_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string LineDefProto::GetTypeName() const {
  return "LineDefProto";
}


// ===================================================================

#ifndef _MSC_VER
const int AreaRuleProto::kColorFieldNumber;
const int AreaRuleProto::kBorderFieldNumber;
const int AreaRuleProto::kPriorityFieldNumber;
#endif  // !_MSC_VER

AreaRuleProto::AreaRuleProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
}

void AreaRuleProto::InitAsDefaultInstance() {
  border_ = const_cast< ::LineDefProto*>(&::LineDefProto::default_instance());
}

AreaRuleProto::AreaRuleProto(const AreaRuleProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
}

void AreaRuleProto::SharedCtor() {
  _cached_size_ = 0;
  color_ = 0u;
  border_ = NULL;
  priority_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

AreaRuleProto::~AreaRuleProto() {
  SharedDtor();
}

void AreaRuleProto::SharedDtor() {
  if (this != default_instance_) {
    delete border_;
  }
}

void AreaRuleProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const AreaRuleProto& AreaRuleProto::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
}

AreaRuleProto* AreaRuleProto::default_instance_ = NULL;

AreaRuleProto* AreaRuleProto::New() const {
  return new AreaRuleProto;
}

void AreaRuleProto::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    color_ = 0u;
    if (has_border()) {
      if (border_ != NULL) border_->::LineDefProto::Clear();
    }
    priority_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

bool AreaRuleProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 color = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &color_)));
          set_has_color();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_border;
        break;
      }
      
      // optional .LineDefProto border = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_border:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_border()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_priority;
        break;
      }
      
      // required int32 priority = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_priority:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &priority_)));
          set_has_priority();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void AreaRuleProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required uint32 color = 1;
  if (has_color()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->color(), output);
  }
  
  // optional .LineDefProto border = 2;
  if (has_border()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, this->border(), output);
  }
  
  // required int32 priority = 3;
  if (has_priority()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->priority(), output);
  }
  
}

int AreaRuleProto::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 color = 1;
    if (has_color()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->color());
    }
    
    // optional .LineDefProto border = 2;
    if (has_border()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->border());
    }
    
    // required int32 priority = 3;
    if (has_priority()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->priority());
    }
    
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void AreaRuleProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<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()) {
      set_color(from.color());
    }
    if (from.has_border()) {
      mutable_border()->::LineDefProto::MergeFrom(from.border());
    }
    if (from.has_priority()) {
      set_priority(from.priority());
    }
  }
}

void AreaRuleProto::CopyFrom(const AreaRuleProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AreaRuleProto::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false;
  
  if (has_border()) {
    if (!this->border().IsInitialized()) return false;
  }
  return true;
}

void AreaRuleProto::Swap(AreaRuleProto* other) {
  if (other != this) {
    std::swap(color_, other->color_);
    std::swap(border_, other->border_);
    std::swap(priority_, other->priority_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string AreaRuleProto::GetTypeName() const {
  return "AreaRuleProto";
}


// ===================================================================

#ifndef _MSC_VER
const int SymbolRuleProto::kNameFieldNumber;
const int SymbolRuleProto::kApplyForTypeFieldNumber;
const int SymbolRuleProto::kPriorityFieldNumber;
#endif  // !_MSC_VER

SymbolRuleProto::SymbolRuleProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
}

void SymbolRuleProto::InitAsDefaultInstance() {
}

SymbolRuleProto::SymbolRuleProto(const SymbolRuleProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
}

void SymbolRuleProto::SharedCtor() {
  _cached_size_ = 0;
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  apply_for_type_ = 0;
  priority_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

SymbolRuleProto::~SymbolRuleProto() {
  SharedDtor();
}

void SymbolRuleProto::SharedDtor() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    delete name_;
  }
  if (this != default_instance_) {
  }
}

void SymbolRuleProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const SymbolRuleProto& SymbolRuleProto::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
}

SymbolRuleProto* SymbolRuleProto::default_instance_ = NULL;

SymbolRuleProto* SymbolRuleProto::New() const {
  return new SymbolRuleProto;
}

void SymbolRuleProto::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::kEmptyString) {
        name_->clear();
      }
    }
    apply_for_type_ = 0;
    priority_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

bool SymbolRuleProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string name = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_apply_for_type;
        break;
      }
      
      // optional int32 apply_for_type = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_apply_for_type:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &apply_for_type_)));
          set_has_apply_for_type();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_priority;
        break;
      }
      
      // required int32 priority = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_priority:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &priority_)));
          set_has_priority();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void SymbolRuleProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->name(), output);
  }
  
  // optional int32 apply_for_type = 2;
  if (has_apply_for_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->apply_for_type(), output);
  }
  
  // required int32 priority = 3;
  if (has_priority()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->priority(), output);
  }
  
}

int SymbolRuleProto::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string name = 1;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }
    
    // optional int32 apply_for_type = 2;
    if (has_apply_for_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->apply_for_type());
    }
    
    // required int32 priority = 3;
    if (has_priority()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->priority());
    }
    
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void SymbolRuleProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<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());
    }
    if (from.has_apply_for_type()) {
      set_apply_for_type(from.apply_for_type());
    }
    if (from.has_priority()) {
      set_priority(from.priority());
    }
  }
}

void SymbolRuleProto::CopyFrom(const SymbolRuleProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SymbolRuleProto::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false;
  
  return true;
}

void SymbolRuleProto::Swap(SymbolRuleProto* other) {
  if (other != this) {
    std::swap(name_, other->name_);
    std::swap(apply_for_type_, other->apply_for_type_);
    std::swap(priority_, other->priority_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string SymbolRuleProto::GetTypeName() const {
  return "SymbolRuleProto";
}


// ===================================================================

#ifndef _MSC_VER
const int CaptionDefProto::kHeightFieldNumber;
const int CaptionDefProto::kColorFieldNumber;
const int CaptionDefProto::kStrokeColorFieldNumber;
const int CaptionDefProto::kOffsetXFieldNumber;
const int CaptionDefProto::kOffsetYFieldNumber;
#endif  // !_MSC_VER

CaptionDefProto::CaptionDefProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
}

void CaptionDefProto::InitAsDefaultInstance() {
}

CaptionDefProto::CaptionDefProto(const CaptionDefProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
}

void CaptionDefProto::SharedCtor() {
  _cached_size_ = 0;
  height_ = 0;
  color_ = 0u;
  stroke_color_ = 0u;
  offset_x_ = 0;
  offset_y_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CaptionDefProto::~CaptionDefProto() {
  SharedDtor();
}

void CaptionDefProto::SharedDtor() {
  if (this != default_instance_) {
  }
}

void CaptionDefProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const CaptionDefProto& CaptionDefProto::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
}

CaptionDefProto* CaptionDefProto::default_instance_ = NULL;

CaptionDefProto* CaptionDefProto::New() const {
  return new CaptionDefProto;
}

void CaptionDefProto::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    height_ = 0;
    color_ = 0u;
    stroke_color_ = 0u;
    offset_x_ = 0;
    offset_y_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

bool CaptionDefProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required int32 height = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &height_)));
          set_has_height();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_color;
        break;
      }
      
      // required uint32 color = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_color:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &color_)));
          set_has_color();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_stroke_color;
        break;
      }
      
      // optional uint32 stroke_color = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_stroke_color:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &stroke_color_)));
          set_has_stroke_color();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_offset_x;
        break;
      }
      
      // optional int32 offset_x = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_offset_x:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &offset_x_)));
          set_has_offset_x();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(40)) goto parse_offset_y;
        break;
      }
      
      // optional int32 offset_y = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_offset_y:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &offset_y_)));
          set_has_offset_y();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CaptionDefProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required int32 height = 1;
  if (has_height()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->height(), output);
  }
  
  // required uint32 color = 2;
  if (has_color()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->color(), output);
  }
  
  // optional uint32 stroke_color = 3;
  if (has_stroke_color()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->stroke_color(), output);
  }
  
  // optional int32 offset_x = 4;
  if (has_offset_x()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->offset_x(), output);
  }
  
  // optional int32 offset_y = 5;
  if (has_offset_y()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->offset_y(), output);
  }
  
}

int CaptionDefProto::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required int32 height = 1;
    if (has_height()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->height());
    }
    
    // required uint32 color = 2;
    if (has_color()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->color());
    }
    
    // optional uint32 stroke_color = 3;
    if (has_stroke_color()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->stroke_color());
    }
    
    // optional int32 offset_x = 4;
    if (has_offset_x()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->offset_x());
    }
    
    // optional int32 offset_y = 5;
    if (has_offset_y()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->offset_y());
    }
    
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void CaptionDefProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const CaptionDefProto*>(&from));
}

void CaptionDefProto::MergeFrom(const CaptionDefProto& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_height()) {
      set_height(from.height());
    }
    if (from.has_color()) {
      set_color(from.color());
    }
    if (from.has_stroke_color()) {
      set_stroke_color(from.stroke_color());
    }
    if (from.has_offset_x()) {
      set_offset_x(from.offset_x());
    }
    if (from.has_offset_y()) {
      set_offset_y(from.offset_y());
    }
  }
}

void CaptionDefProto::CopyFrom(const CaptionDefProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CaptionDefProto::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
  
  return true;
}

void CaptionDefProto::Swap(CaptionDefProto* other) {
  if (other != this) {
    std::swap(height_, other->height_);
    std::swap(color_, other->color_);
    std::swap(stroke_color_, other->stroke_color_);
    std::swap(offset_x_, other->offset_x_);
    std::swap(offset_y_, other->offset_y_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string CaptionDefProto::GetTypeName() const {
  return "CaptionDefProto";
}


// ===================================================================

#ifndef _MSC_VER
const int CaptionRuleProto::kPrimaryFieldNumber;
const int CaptionRuleProto::kSecondaryFieldNumber;
const int CaptionRuleProto::kPriorityFieldNumber;
#endif  // !_MSC_VER

CaptionRuleProto::CaptionRuleProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
}

void CaptionRuleProto::InitAsDefaultInstance() {
  primary_ = const_cast< ::CaptionDefProto*>(&::CaptionDefProto::default_instance());
  secondary_ = const_cast< ::CaptionDefProto*>(&::CaptionDefProto::default_instance());
}

CaptionRuleProto::CaptionRuleProto(const CaptionRuleProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
}

void CaptionRuleProto::SharedCtor() {
  _cached_size_ = 0;
  primary_ = NULL;
  secondary_ = NULL;
  priority_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CaptionRuleProto::~CaptionRuleProto() {
  SharedDtor();
}

void CaptionRuleProto::SharedDtor() {
  if (this != default_instance_) {
    delete primary_;
    delete secondary_;
  }
}

void CaptionRuleProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const CaptionRuleProto& CaptionRuleProto::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
}

CaptionRuleProto* CaptionRuleProto::default_instance_ = NULL;

CaptionRuleProto* CaptionRuleProto::New() const {
  return new CaptionRuleProto;
}

void CaptionRuleProto::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_primary()) {
      if (primary_ != NULL) primary_->::CaptionDefProto::Clear();
    }
    if (has_secondary()) {
      if (secondary_ != NULL) secondary_->::CaptionDefProto::Clear();
    }
    priority_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

bool CaptionRuleProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .CaptionDefProto primary = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_primary()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_secondary;
        break;
      }
      
      // optional .CaptionDefProto secondary = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_secondary:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_secondary()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_priority;
        break;
      }
      
      // required int32 priority = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_priority:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &priority_)));
          set_has_priority();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CaptionRuleProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .CaptionDefProto primary = 1;
  if (has_primary()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      1, this->primary(), output);
  }
  
  // optional .CaptionDefProto secondary = 2;
  if (has_secondary()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, this->secondary(), output);
  }
  
  // required int32 priority = 3;
  if (has_priority()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->priority(), output);
  }
  
}

int CaptionRuleProto::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .CaptionDefProto primary = 1;
    if (has_primary()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->primary());
    }
    
    // optional .CaptionDefProto secondary = 2;
    if (has_secondary()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->secondary());
    }
    
    // required int32 priority = 3;
    if (has_priority()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->priority());
    }
    
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void CaptionRuleProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<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_primary()) {
      mutable_primary()->::CaptionDefProto::MergeFrom(from.primary());
    }
    if (from.has_secondary()) {
      mutable_secondary()->::CaptionDefProto::MergeFrom(from.secondary());
    }
    if (from.has_priority()) {
      set_priority(from.priority());
    }
  }
}

void CaptionRuleProto::CopyFrom(const CaptionRuleProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CaptionRuleProto::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false;
  
  if (has_primary()) {
    if (!this->primary().IsInitialized()) return false;
  }
  if (has_secondary()) {
    if (!this->secondary().IsInitialized()) return false;
  }
  return true;
}

void CaptionRuleProto::Swap(CaptionRuleProto* other) {
  if (other != this) {
    std::swap(primary_, other->primary_);
    std::swap(secondary_, other->secondary_);
    std::swap(priority_, other->priority_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string CaptionRuleProto::GetTypeName() const {
  return "CaptionRuleProto";
}


// ===================================================================

#ifndef _MSC_VER
const int CircleRuleProto::kRadiusFieldNumber;
const int CircleRuleProto::kColorFieldNumber;
const int CircleRuleProto::kBorderFieldNumber;
const int CircleRuleProto::kPriorityFieldNumber;
#endif  // !_MSC_VER

CircleRuleProto::CircleRuleProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
}

void CircleRuleProto::InitAsDefaultInstance() {
  border_ = const_cast< ::LineDefProto*>(&::LineDefProto::default_instance());
}

CircleRuleProto::CircleRuleProto(const CircleRuleProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
}

void CircleRuleProto::SharedCtor() {
  _cached_size_ = 0;
  radius_ = 0;
  color_ = 0u;
  border_ = NULL;
  priority_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CircleRuleProto::~CircleRuleProto() {
  SharedDtor();
}

void CircleRuleProto::SharedDtor() {
  if (this != default_instance_) {
    delete border_;
  }
}

void CircleRuleProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const CircleRuleProto& CircleRuleProto::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
}

CircleRuleProto* CircleRuleProto::default_instance_ = NULL;

CircleRuleProto* CircleRuleProto::New() const {
  return new CircleRuleProto;
}

void CircleRuleProto::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    radius_ = 0;
    color_ = 0u;
    if (has_border()) {
      if (border_ != NULL) border_->::LineDefProto::Clear();
    }
    priority_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

bool CircleRuleProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required double radius = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &radius_)));
          set_has_radius();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_color;
        break;
      }
      
      // required uint32 color = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_color:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &color_)));
          set_has_color();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_border;
        break;
      }
      
      // optional .LineDefProto border = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_border:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_border()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_priority;
        break;
      }
      
      // required int32 priority = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_priority:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &priority_)));
          set_has_priority();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CircleRuleProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required double radius = 1;
  if (has_radius()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->radius(), output);
  }
  
  // required uint32 color = 2;
  if (has_color()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->color(), output);
  }
  
  // optional .LineDefProto border = 3;
  if (has_border()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      3, this->border(), output);
  }
  
  // required int32 priority = 4;
  if (has_priority()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->priority(), output);
  }
  
}

int CircleRuleProto::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required double radius = 1;
    if (has_radius()) {
      total_size += 1 + 8;
    }
    
    // required uint32 color = 2;
    if (has_color()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->color());
    }
    
    // optional .LineDefProto border = 3;
    if (has_border()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->border());
    }
    
    // required int32 priority = 4;
    if (has_priority()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->priority());
    }
    
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void CircleRuleProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<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_radius()) {
      set_radius(from.radius());
    }
    if (from.has_color()) {
      set_color(from.color());
    }
    if (from.has_border()) {
      mutable_border()->::LineDefProto::MergeFrom(from.border());
    }
    if (from.has_priority()) {
      set_priority(from.priority());
    }
  }
}

void CircleRuleProto::CopyFrom(const CircleRuleProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CircleRuleProto::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000000b) != 0x0000000b) return false;
  
  if (has_border()) {
    if (!this->border().IsInitialized()) return false;
  }
  return true;
}

void CircleRuleProto::Swap(CircleRuleProto* other) {
  if (other != this) {
    std::swap(radius_, other->radius_);
    std::swap(color_, other->color_);
    std::swap(border_, other->border_);
    std::swap(priority_, other->priority_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string CircleRuleProto::GetTypeName() const {
  return "CircleRuleProto";
}


// ===================================================================

#ifndef _MSC_VER
const int PathTextRuleProto::kPrimaryFieldNumber;
const int PathTextRuleProto::kSecondaryFieldNumber;
const int PathTextRuleProto::kPriorityFieldNumber;
#endif  // !_MSC_VER

PathTextRuleProto::PathTextRuleProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
}

void PathTextRuleProto::InitAsDefaultInstance() {
  primary_ = const_cast< ::CaptionDefProto*>(&::CaptionDefProto::default_instance());
  secondary_ = const_cast< ::CaptionDefProto*>(&::CaptionDefProto::default_instance());
}

PathTextRuleProto::PathTextRuleProto(const PathTextRuleProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
}

void PathTextRuleProto::SharedCtor() {
  _cached_size_ = 0;
  primary_ = NULL;
  secondary_ = NULL;
  priority_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

PathTextRuleProto::~PathTextRuleProto() {
  SharedDtor();
}

void PathTextRuleProto::SharedDtor() {
  if (this != default_instance_) {
    delete primary_;
    delete secondary_;
  }
}

void PathTextRuleProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const PathTextRuleProto& PathTextRuleProto::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
}

PathTextRuleProto* PathTextRuleProto::default_instance_ = NULL;

PathTextRuleProto* PathTextRuleProto::New() const {
  return new PathTextRuleProto;
}

void PathTextRuleProto::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_primary()) {
      if (primary_ != NULL) primary_->::CaptionDefProto::Clear();
    }
    if (has_secondary()) {
      if (secondary_ != NULL) secondary_->::CaptionDefProto::Clear();
    }
    priority_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

bool PathTextRuleProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .CaptionDefProto primary = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_primary()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_secondary;
        break;
      }
      
      // optional .CaptionDefProto secondary = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_secondary:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_secondary()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_priority;
        break;
      }
      
      // required int32 priority = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_priority:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &priority_)));
          set_has_priority();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void PathTextRuleProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .CaptionDefProto primary = 1;
  if (has_primary()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      1, this->primary(), output);
  }
  
  // optional .CaptionDefProto secondary = 2;
  if (has_secondary()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, this->secondary(), output);
  }
  
  // required int32 priority = 3;
  if (has_priority()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->priority(), output);
  }
  
}

int PathTextRuleProto::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .CaptionDefProto primary = 1;
    if (has_primary()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->primary());
    }
    
    // optional .CaptionDefProto secondary = 2;
    if (has_secondary()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->secondary());
    }
    
    // required int32 priority = 3;
    if (has_priority()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->priority());
    }
    
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PathTextRuleProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const PathTextRuleProto*>(&from));
}

void PathTextRuleProto::MergeFrom(const PathTextRuleProto& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_primary()) {
      mutable_primary()->::CaptionDefProto::MergeFrom(from.primary());
    }
    if (from.has_secondary()) {
      mutable_secondary()->::CaptionDefProto::MergeFrom(from.secondary());
    }
    if (from.has_priority()) {
      set_priority(from.priority());
    }
  }
}

void PathTextRuleProto::CopyFrom(const PathTextRuleProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PathTextRuleProto::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false;
  
  if (has_primary()) {
    if (!this->primary().IsInitialized()) return false;
  }
  if (has_secondary()) {
    if (!this->secondary().IsInitialized()) return false;
  }
  return true;
}

void PathTextRuleProto::Swap(PathTextRuleProto* other) {
  if (other != this) {
    std::swap(primary_, other->primary_);
    std::swap(secondary_, other->secondary_);
    std::swap(priority_, other->priority_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string PathTextRuleProto::GetTypeName() const {
  return "PathTextRuleProto";
}


// ===================================================================

#ifndef _MSC_VER
const int DrawElementProto::kScaleFieldNumber;
const int DrawElementProto::kLinesFieldNumber;
const int DrawElementProto::kAreaFieldNumber;
const int DrawElementProto::kSymbolFieldNumber;
const int DrawElementProto::kCaptionFieldNumber;
const int DrawElementProto::kCircleFieldNumber;
const int DrawElementProto::kPathTextFieldNumber;
#endif  // !_MSC_VER

DrawElementProto::DrawElementProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
}

void DrawElementProto::InitAsDefaultInstance() {
  area_ = const_cast< ::AreaRuleProto*>(&::AreaRuleProto::default_instance());
  symbol_ = const_cast< ::SymbolRuleProto*>(&::SymbolRuleProto::default_instance());
  caption_ = const_cast< ::CaptionRuleProto*>(&::CaptionRuleProto::default_instance());
  circle_ = const_cast< ::CircleRuleProto*>(&::CircleRuleProto::default_instance());
  path_text_ = const_cast< ::PathTextRuleProto*>(&::PathTextRuleProto::default_instance());
}

DrawElementProto::DrawElementProto(const DrawElementProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
}

void DrawElementProto::SharedCtor() {
  _cached_size_ = 0;
  scale_ = 0;
  area_ = NULL;
  symbol_ = NULL;
  caption_ = NULL;
  circle_ = NULL;
  path_text_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

DrawElementProto::~DrawElementProto() {
  SharedDtor();
}

void DrawElementProto::SharedDtor() {
  if (this != default_instance_) {
    delete area_;
    delete symbol_;
    delete caption_;
    delete circle_;
    delete path_text_;
  }
}

void DrawElementProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const DrawElementProto& DrawElementProto::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
}

DrawElementProto* DrawElementProto::default_instance_ = NULL;

DrawElementProto* DrawElementProto::New() const {
  return new DrawElementProto;
}

void DrawElementProto::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    scale_ = 0;
    if (has_area()) {
      if (area_ != NULL) area_->::AreaRuleProto::Clear();
    }
    if (has_symbol()) {
      if (symbol_ != NULL) symbol_->::SymbolRuleProto::Clear();
    }
    if (has_caption()) {
      if (caption_ != NULL) caption_->::CaptionRuleProto::Clear();
    }
    if (has_circle()) {
      if (circle_ != NULL) circle_->::CircleRuleProto::Clear();
    }
    if (has_path_text()) {
      if (path_text_ != NULL) path_text_->::PathTextRuleProto::Clear();
    }
  }
  lines_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

bool DrawElementProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required int32 scale = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &scale_)));
          set_has_scale();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_lines;
        break;
      }
      
      // repeated .LineRuleProto lines = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_lines:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_lines()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_lines;
        if (input->ExpectTag(26)) goto parse_area;
        break;
      }
      
      // optional .AreaRuleProto area = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_area:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_area()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_symbol;
        break;
      }
      
      // optional .SymbolRuleProto symbol = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_symbol:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_symbol()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(42)) goto parse_caption;
        break;
      }
      
      // optional .CaptionRuleProto caption = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_caption:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_caption()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(50)) goto parse_circle;
        break;
      }
      
      // optional .CircleRuleProto circle = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_circle:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_circle()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(58)) goto parse_path_text;
        break;
      }
      
      // optional .PathTextRuleProto path_text = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_path_text:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_path_text()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void DrawElementProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required int32 scale = 1;
  if (has_scale()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->scale(), output);
  }
  
  // repeated .LineRuleProto lines = 2;
  for (int i = 0; i < this->lines_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, this->lines(i), output);
  }
  
  // optional .AreaRuleProto area = 3;
  if (has_area()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      3, this->area(), output);
  }
  
  // optional .SymbolRuleProto symbol = 4;
  if (has_symbol()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      4, this->symbol(), output);
  }
  
  // optional .CaptionRuleProto caption = 5;
  if (has_caption()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      5, this->caption(), output);
  }
  
  // optional .CircleRuleProto circle = 6;
  if (has_circle()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      6, this->circle(), output);
  }
  
  // optional .PathTextRuleProto path_text = 7;
  if (has_path_text()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      7, this->path_text(), output);
  }
  
}

int DrawElementProto::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required int32 scale = 1;
    if (has_scale()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->scale());
    }
    
    // optional .AreaRuleProto area = 3;
    if (has_area()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->area());
    }
    
    // optional .SymbolRuleProto symbol = 4;
    if (has_symbol()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->symbol());
    }
    
    // optional .CaptionRuleProto caption = 5;
    if (has_caption()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->caption());
    }
    
    // optional .CircleRuleProto circle = 6;
    if (has_circle()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->circle());
    }
    
    // optional .PathTextRuleProto path_text = 7;
    if (has_path_text()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->path_text());
    }
    
  }
  // repeated .LineRuleProto lines = 2;
  total_size += 1 * this->lines_size();
  for (int i = 0; i < this->lines_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->lines(i));
  }
  
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DrawElementProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<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_symbol()) {
      mutable_symbol()->::SymbolRuleProto::MergeFrom(from.symbol());
    }
    if (from.has_caption()) {
      mutable_caption()->::CaptionRuleProto::MergeFrom(from.caption());
    }
    if (from.has_circle()) {
      mutable_circle()->::CircleRuleProto::MergeFrom(from.circle());
    }
    if (from.has_path_text()) {
      mutable_path_text()->::PathTextRuleProto::MergeFrom(from.path_text());
    }
  }
}

void DrawElementProto::CopyFrom(const DrawElementProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DrawElementProto::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
  
  for (int i = 0; i < lines_size(); i++) {
    if (!this->lines(i).IsInitialized()) return false;
  }
  if (has_area()) {
    if (!this->area().IsInitialized()) return false;
  }
  if (has_symbol()) {
    if (!this->symbol().IsInitialized()) return false;
  }
  if (has_caption()) {
    if (!this->caption().IsInitialized()) return false;
  }
  if (has_circle()) {
    if (!this->circle().IsInitialized()) return false;
  }
  if (has_path_text()) {
    if (!this->path_text().IsInitialized()) return false;
  }
  return true;
}

void DrawElementProto::Swap(DrawElementProto* other) {
  if (other != this) {
    std::swap(scale_, other->scale_);
    lines_.Swap(&other->lines_);
    std::swap(area_, other->area_);
    std::swap(symbol_, other->symbol_);
    std::swap(caption_, other->caption_);
    std::swap(circle_, other->circle_);
    std::swap(path_text_, other->path_text_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string DrawElementProto::GetTypeName() const {
  return "DrawElementProto";
}


// ===================================================================

#ifndef _MSC_VER
const int ClassifElementProto::kNameFieldNumber;
const int ClassifElementProto::kElementFieldNumber;
#endif  // !_MSC_VER

ClassifElementProto::ClassifElementProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
}

void ClassifElementProto::InitAsDefaultInstance() {
}

ClassifElementProto::ClassifElementProto(const ClassifElementProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
}

void ClassifElementProto::SharedCtor() {
  _cached_size_ = 0;
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ClassifElementProto::~ClassifElementProto() {
  SharedDtor();
}

void ClassifElementProto::SharedDtor() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    delete name_;
  }
  if (this != default_instance_) {
  }
}

void ClassifElementProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ClassifElementProto& ClassifElementProto::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
}

ClassifElementProto* ClassifElementProto::default_instance_ = NULL;

ClassifElementProto* ClassifElementProto::New() const {
  return new ClassifElementProto;
}

void ClassifElementProto::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::kEmptyString) {
        name_->clear();
      }
    }
  }
  element_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

bool ClassifElementProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string name = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_element;
        break;
      }
      
      // repeated .DrawElementProto element = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_element:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_element()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_element;
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void ClassifElementProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->name(), output);
  }
  
  // repeated .DrawElementProto element = 2;
  for (int i = 0; i < this->element_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, this->element(i), output);
  }
  
}

int ClassifElementProto::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string name = 1;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }
    
  }
  // repeated .DrawElementProto element = 2;
  total_size += 1 * this->element_size();
  for (int i = 0; i < this->element_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->element(i));
  }
  
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ClassifElementProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ClassifElementProto*>(&from));
}

void ClassifElementProto::MergeFrom(const ClassifElementProto& from) {
  GOOGLE_CHECK_NE(&from, this);
  element_.MergeFrom(from.element_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_name()) {
      set_name(from.name());
    }
  }
}

void ClassifElementProto::CopyFrom(const ClassifElementProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ClassifElementProto::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
  
  for (int i = 0; i < element_size(); i++) {
    if (!this->element(i).IsInitialized()) return false;
  }
  return true;
}

void ClassifElementProto::Swap(ClassifElementProto* other) {
  if (other != this) {
    std::swap(name_, other->name_);
    element_.Swap(&other->element_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string ClassifElementProto::GetTypeName() const {
  return "ClassifElementProto";
}


// ===================================================================

#ifndef _MSC_VER
const int ContainerProto::kContFieldNumber;
#endif  // !_MSC_VER

ContainerProto::ContainerProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
}

void ContainerProto::InitAsDefaultInstance() {
}

ContainerProto::ContainerProto(const ContainerProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
}

void ContainerProto::SharedCtor() {
  _cached_size_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ContainerProto::~ContainerProto() {
  SharedDtor();
}

void ContainerProto::SharedDtor() {
  if (this != default_instance_) {
  }
}

void ContainerProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ContainerProto& ContainerProto::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
}

ContainerProto* ContainerProto::default_instance_ = NULL;

ContainerProto* ContainerProto::New() const {
  return new ContainerProto;
}

void ContainerProto::Clear() {
  cont_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

bool ContainerProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .ClassifElementProto cont = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_cont:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_cont()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(10)) goto parse_cont;
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void ContainerProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // repeated .ClassifElementProto cont = 1;
  for (int i = 0; i < this->cont_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      1, this->cont(i), output);
  }
  
}

int ContainerProto::ByteSize() const {
  int total_size = 0;
  
  // repeated .ClassifElementProto cont = 1;
  total_size += 1 * this->cont_size();
  for (int i = 0; i < this->cont_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->cont(i));
  }
  
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ContainerProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<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)