modularization/src/tool/tracetoxodr/geodata.pb.cc

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: geodata.proto

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "geodata.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/port.h>
#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)

namespace iv {
namespace map {

namespace {

const ::google::protobuf::Descriptor* Point_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Point_reflection_ = NULL;
const ::google::protobuf::Descriptor* geodata_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  geodata_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* geotype_descriptor_ = NULL;

}  // namespace


void protobuf_AssignDesc_geodata_2eproto() GOOGLE_ATTRIBUTE_COLD;
void protobuf_AssignDesc_geodata_2eproto() {
  protobuf_AddDesc_geodata_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "geodata.proto");
  GOOGLE_CHECK(file != NULL);
  Point_descriptor_ = file->message_type(0);
  static const int Point_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Point, x_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Point, y_),
  };
  Point_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      Point_descriptor_,
      Point::default_instance_,
      Point_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Point, _has_bits_[0]),
      -1,
      -1,
      sizeof(Point),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Point, _internal_metadata_),
      -1);
  geodata_descriptor_ = file->message_type(1);
  static const int geodata_offsets_[25] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, index_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, start_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, end_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, hdg_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, index_start_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, index_end_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, off_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, curvature_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, s_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, curvcenter_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, mindis_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, maxdis_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, hdg_start_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, hdg_end_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, au_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, bu_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, cu_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, du_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, av_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, bv_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, cv_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, dv_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, polyuratio_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, polyvratio_),
  };
  geodata_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      geodata_descriptor_,
      geodata::default_instance_,
      geodata_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, _has_bits_[0]),
      -1,
      -1,
      sizeof(geodata),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(geodata, _internal_metadata_),
      -1);
  geotype_descriptor_ = file->enum_type(0);
}

namespace {

GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
inline void protobuf_AssignDescriptorsOnce() {
  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
                 &protobuf_AssignDesc_geodata_2eproto);
}

void protobuf_RegisterTypes(const ::std::string&) GOOGLE_ATTRIBUTE_COLD;
void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      Point_descriptor_, &Point::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      geodata_descriptor_, &geodata::default_instance());
}

}  // namespace

void protobuf_ShutdownFile_geodata_2eproto() {
  delete Point::default_instance_;
  delete Point_reflection_;
  delete geodata::default_instance_;
  delete geodata_reflection_;
}

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

  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\n\rgeodata.proto\022\006iv.map\"\035\n\005Point\022\t\n\001x\030\001 "
    "\002(\001\022\t\n\001y\030\002 \002(\001\"\300\003\n\007geodata\022\r\n\005index\030\001 \001("
    "\r\022\034\n\005start\030\002 \002(\0132\r.iv.map.Point\022\032\n\003end\030\003"
    " \002(\0132\r.iv.map.Point\022\013\n\003hdg\030\004 \001(\001\022\023\n\013inde"
    "x_start\030\005 \001(\005\022\021\n\tindex_end\030\006 \001(\005\022\013\n\003off\030"
    "\007 \001(\001\022\021\n\tcurvature\030\010 \001(\001\022\t\n\001s\030\n \001(\001\022\035\n\004t"
    "ype\030\t \002(\0162\017.iv.map.geotype\022!\n\ncurvcenter"
    "\030\013 \001(\0132\r.iv.map.Point\022\016\n\006mindis\030\014 \001(\001\022\016\n"
    "\006maxdis\030\r \001(\001\022\021\n\thdg_start\030\016 \001(\001\022\017\n\007hdg_"
    "end\030\017 \001(\001\022\n\n\002au\030\020 \001(\001\022\n\n\002bu\030\021 \001(\001\022\n\n\002cu\030"
    "\022 \001(\001\022\n\n\002du\030\023 \001(\001\022\n\n\002av\030\024 \001(\001\022\n\n\002bv\030\025 \001("
    "\001\022\n\n\002cv\030\026 \001(\001\022\n\n\002dv\030\027 \001(\001\022\022\n\npolyuratio\030"
    "\030 \001(\001\022\022\n\npolyvratio\030\031 \001(\001*,\n\007geotype\022\010\n\004"
    "LINE\020\000\022\007\n\003ARC\020\001\022\016\n\nPARAMPOLY3\020\002", 551);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "geodata.proto", &protobuf_RegisterTypes);
  Point::default_instance_ = new Point();
  geodata::default_instance_ = new geodata();
  Point::default_instance_->InitAsDefaultInstance();
  geodata::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_geodata_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_geodata_2eproto {
  StaticDescriptorInitializer_geodata_2eproto() {
    protobuf_AddDesc_geodata_2eproto();
  }
} static_descriptor_initializer_geodata_2eproto_;
const ::google::protobuf::EnumDescriptor* geotype_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return geotype_descriptor_;
}
bool geotype_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}


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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int Point::kXFieldNumber;
const int Point::kYFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

Point::Point()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iv.map.Point)
}

void Point::InitAsDefaultInstance() {
}

Point::Point(const Point& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iv.map.Point)
}

void Point::SharedCtor() {
  _cached_size_ = 0;
  x_ = 0;
  y_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Point::~Point() {
  // @@protoc_insertion_point(destructor:iv.map.Point)
  SharedDtor();
}

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

void Point::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Point::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Point_descriptor_;
}

const Point& Point::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_geodata_2eproto();
  return *default_instance_;
}

Point* Point::default_instance_ = NULL;

Point* Point::New(::google::protobuf::Arena* arena) const {
  Point* n = new Point;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void Point::Clear() {
// @@protoc_insertion_point(message_clear_start:iv.map.Point)
#if defined(__clang__)
#define ZR_HELPER_(f) \
  _Pragma("clang diagnostic push") \
  _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \
  __builtin_offsetof(Point, f) \
  _Pragma("clang diagnostic pop")
#else
#define ZR_HELPER_(f) reinterpret_cast<char*>(\
  &reinterpret_cast<Point*>(16)->f)
#endif

#define ZR_(first, last) do {\
  ::memset(&first, 0,\
           ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\
} while (0)

  ZR_(x_, y_);

#undef ZR_HELPER_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool Point::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iv.map.Point)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required double x = 1;
      case 1: {
        if (tag == 9) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &x_)));
          set_has_x();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(17)) goto parse_y;
        break;
      }

      // required double y = 2;
      case 2: {
        if (tag == 17) {
         parse_y:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &y_)));
          set_has_y();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iv.map.Point)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iv.map.Point)
  return false;
#undef DO_
}

void Point::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iv.map.Point)
  // required double x = 1;
  if (has_x()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->x(), output);
  }

  // required double y = 2;
  if (has_y()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->y(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iv.map.Point)
}

::google::protobuf::uint8* Point::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iv.map.Point)
  // required double x = 1;
  if (has_x()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(1, this->x(), target);
  }

  // required double y = 2;
  if (has_y()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(2, this->y(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iv.map.Point)
  return target;
}

int Point::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:iv.map.Point)
  int total_size = 0;

  if (has_x()) {
    // required double x = 1;
    total_size += 1 + 8;
  }

  if (has_y()) {
    // required double y = 2;
    total_size += 1 + 8;
  }

  return total_size;
}
int Point::ByteSize() const {
// @@protoc_insertion_point(message_byte_size_start:iv.map.Point)
  int total_size = 0;

  if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) {  // All required fields are present.
    // required double x = 1;
    total_size += 1 + 8;

    // required double y = 2;
    total_size += 1 + 8;

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Point::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:iv.map.Point)
  if (GOOGLE_PREDICT_FALSE(&from == this)) {
    ::google::protobuf::internal::MergeFromFail(__FILE__, __LINE__);
  }
  const Point* source = 
      ::google::protobuf::internal::DynamicCastToGenerated<const Point>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:iv.map.Point)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:iv.map.Point)
    MergeFrom(*source);
  }
}

void Point::MergeFrom(const Point& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:iv.map.Point)
  if (GOOGLE_PREDICT_FALSE(&from == this)) {
    ::google::protobuf::internal::MergeFromFail(__FILE__, __LINE__);
  }
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_x()) {
      set_x(from.x());
    }
    if (from.has_y()) {
      set_y(from.y());
    }
  }
  if (from._internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
}

void Point::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:iv.map.Point)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Point::CopyFrom(const Point& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:iv.map.Point)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

  return true;
}

void Point::Swap(Point* other) {
  if (other == this) return;
  InternalSwap(other);
}
void Point::InternalSwap(Point* other) {
  std::swap(x_, other->x_);
  std::swap(y_, other->y_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata Point::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Point_descriptor_;
  metadata.reflection = Point_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// Point

// required double x = 1;
bool Point::has_x() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void Point::set_has_x() {
  _has_bits_[0] |= 0x00000001u;
}
void Point::clear_has_x() {
  _has_bits_[0] &= ~0x00000001u;
}
void Point::clear_x() {
  x_ = 0;
  clear_has_x();
}
 double Point::x() const {
  // @@protoc_insertion_point(field_get:iv.map.Point.x)
  return x_;
}
 void Point::set_x(double value) {
  set_has_x();
  x_ = value;
  // @@protoc_insertion_point(field_set:iv.map.Point.x)
}

// required double y = 2;
bool Point::has_y() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void Point::set_has_y() {
  _has_bits_[0] |= 0x00000002u;
}
void Point::clear_has_y() {
  _has_bits_[0] &= ~0x00000002u;
}
void Point::clear_y() {
  y_ = 0;
  clear_has_y();
}
 double Point::y() const {
  // @@protoc_insertion_point(field_get:iv.map.Point.y)
  return y_;
}
 void Point::set_y(double value) {
  set_has_y();
  y_ = value;
  // @@protoc_insertion_point(field_set:iv.map.Point.y)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int geodata::kIndexFieldNumber;
const int geodata::kStartFieldNumber;
const int geodata::kEndFieldNumber;
const int geodata::kHdgFieldNumber;
const int geodata::kIndexStartFieldNumber;
const int geodata::kIndexEndFieldNumber;
const int geodata::kOffFieldNumber;
const int geodata::kCurvatureFieldNumber;
const int geodata::kSFieldNumber;
const int geodata::kTypeFieldNumber;
const int geodata::kCurvcenterFieldNumber;
const int geodata::kMindisFieldNumber;
const int geodata::kMaxdisFieldNumber;
const int geodata::kHdgStartFieldNumber;
const int geodata::kHdgEndFieldNumber;
const int geodata::kAuFieldNumber;
const int geodata::kBuFieldNumber;
const int geodata::kCuFieldNumber;
const int geodata::kDuFieldNumber;
const int geodata::kAvFieldNumber;
const int geodata::kBvFieldNumber;
const int geodata::kCvFieldNumber;
const int geodata::kDvFieldNumber;
const int geodata::kPolyuratioFieldNumber;
const int geodata::kPolyvratioFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

geodata::geodata()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iv.map.geodata)
}

void geodata::InitAsDefaultInstance() {
  start_ = const_cast< ::iv::map::Point*>(&::iv::map::Point::default_instance());
  end_ = const_cast< ::iv::map::Point*>(&::iv::map::Point::default_instance());
  curvcenter_ = const_cast< ::iv::map::Point*>(&::iv::map::Point::default_instance());
}

geodata::geodata(const geodata& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iv.map.geodata)
}

void geodata::SharedCtor() {
  _cached_size_ = 0;
  index_ = 0u;
  start_ = NULL;
  end_ = NULL;
  hdg_ = 0;
  index_start_ = 0;
  index_end_ = 0;
  off_ = 0;
  curvature_ = 0;
  s_ = 0;
  type_ = 0;
  curvcenter_ = NULL;
  mindis_ = 0;
  maxdis_ = 0;
  hdg_start_ = 0;
  hdg_end_ = 0;
  au_ = 0;
  bu_ = 0;
  cu_ = 0;
  du_ = 0;
  av_ = 0;
  bv_ = 0;
  cv_ = 0;
  dv_ = 0;
  polyuratio_ = 0;
  polyvratio_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

geodata::~geodata() {
  // @@protoc_insertion_point(destructor:iv.map.geodata)
  SharedDtor();
}

void geodata::SharedDtor() {
  if (this != default_instance_) {
    delete start_;
    delete end_;
    delete curvcenter_;
  }
}

void geodata::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* geodata::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return geodata_descriptor_;
}

const geodata& geodata::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_geodata_2eproto();
  return *default_instance_;
}

geodata* geodata::default_instance_ = NULL;

geodata* geodata::New(::google::protobuf::Arena* arena) const {
  geodata* n = new geodata;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void geodata::Clear() {
// @@protoc_insertion_point(message_clear_start:iv.map.geodata)
#if defined(__clang__)
#define ZR_HELPER_(f) \
  _Pragma("clang diagnostic push") \
  _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \
  __builtin_offsetof(geodata, f) \
  _Pragma("clang diagnostic pop")
#else
#define ZR_HELPER_(f) reinterpret_cast<char*>(\
  &reinterpret_cast<geodata*>(16)->f)
#endif

#define ZR_(first, last) do {\
  ::memset(&first, 0,\
           ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\
} while (0)

  if (_has_bits_[0 / 32] & 255u) {
    ZR_(index_, index_end_);
    if (has_start()) {
      if (start_ != NULL) start_->::iv::map::Point::Clear();
    }
    if (has_end()) {
      if (end_ != NULL) end_->::iv::map::Point::Clear();
    }
  }
  if (_has_bits_[8 / 32] & 65280u) {
    ZR_(type_, s_);
    ZR_(mindis_, au_);
    if (has_curvcenter()) {
      if (curvcenter_ != NULL) curvcenter_->::iv::map::Point::Clear();
    }
  }
  if (_has_bits_[16 / 32] & 16711680u) {
    ZR_(bu_, polyuratio_);
  }
  polyvratio_ = 0;

#undef ZR_HELPER_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool geodata::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iv.map.geodata)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 index = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &index_)));
          set_has_index();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_start;
        break;
      }

      // required .iv.map.Point start = 2;
      case 2: {
        if (tag == 18) {
         parse_start:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_start()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_end;
        break;
      }

      // required .iv.map.Point end = 3;
      case 3: {
        if (tag == 26) {
         parse_end:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_end()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(33)) goto parse_hdg;
        break;
      }

      // optional double hdg = 4;
      case 4: {
        if (tag == 33) {
         parse_hdg:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &hdg_)));
          set_has_hdg();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_index_start;
        break;
      }

      // optional int32 index_start = 5;
      case 5: {
        if (tag == 40) {
         parse_index_start:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &index_start_)));
          set_has_index_start();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_index_end;
        break;
      }

      // optional int32 index_end = 6;
      case 6: {
        if (tag == 48) {
         parse_index_end:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &index_end_)));
          set_has_index_end();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(57)) goto parse_off;
        break;
      }

      // optional double off = 7;
      case 7: {
        if (tag == 57) {
         parse_off:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &off_)));
          set_has_off();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(65)) goto parse_curvature;
        break;
      }

      // optional double curvature = 8;
      case 8: {
        if (tag == 65) {
         parse_curvature:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &curvature_)));
          set_has_curvature();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(72)) goto parse_type;
        break;
      }

      // required .iv.map.geotype type = 9;
      case 9: {
        if (tag == 72) {
         parse_type:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::iv::map::geotype_IsValid(value)) {
            set_type(static_cast< ::iv::map::geotype >(value));
          } else {
            mutable_unknown_fields()->AddVarint(9, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(81)) goto parse_s;
        break;
      }

      // optional double s = 10;
      case 10: {
        if (tag == 81) {
         parse_s:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &s_)));
          set_has_s();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(90)) goto parse_curvcenter;
        break;
      }

      // optional .iv.map.Point curvcenter = 11;
      case 11: {
        if (tag == 90) {
         parse_curvcenter:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_curvcenter()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(97)) goto parse_mindis;
        break;
      }

      // optional double mindis = 12;
      case 12: {
        if (tag == 97) {
         parse_mindis:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &mindis_)));
          set_has_mindis();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(105)) goto parse_maxdis;
        break;
      }

      // optional double maxdis = 13;
      case 13: {
        if (tag == 105) {
         parse_maxdis:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &maxdis_)));
          set_has_maxdis();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(113)) goto parse_hdg_start;
        break;
      }

      // optional double hdg_start = 14;
      case 14: {
        if (tag == 113) {
         parse_hdg_start:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &hdg_start_)));
          set_has_hdg_start();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(121)) goto parse_hdg_end;
        break;
      }

      // optional double hdg_end = 15;
      case 15: {
        if (tag == 121) {
         parse_hdg_end:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &hdg_end_)));
          set_has_hdg_end();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(129)) goto parse_au;
        break;
      }

      // optional double au = 16;
      case 16: {
        if (tag == 129) {
         parse_au:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &au_)));
          set_has_au();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(137)) goto parse_bu;
        break;
      }

      // optional double bu = 17;
      case 17: {
        if (tag == 137) {
         parse_bu:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &bu_)));
          set_has_bu();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(145)) goto parse_cu;
        break;
      }

      // optional double cu = 18;
      case 18: {
        if (tag == 145) {
         parse_cu:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &cu_)));
          set_has_cu();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(153)) goto parse_du;
        break;
      }

      // optional double du = 19;
      case 19: {
        if (tag == 153) {
         parse_du:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &du_)));
          set_has_du();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(161)) goto parse_av;
        break;
      }

      // optional double av = 20;
      case 20: {
        if (tag == 161) {
         parse_av:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &av_)));
          set_has_av();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(169)) goto parse_bv;
        break;
      }

      // optional double bv = 21;
      case 21: {
        if (tag == 169) {
         parse_bv:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &bv_)));
          set_has_bv();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(177)) goto parse_cv;
        break;
      }

      // optional double cv = 22;
      case 22: {
        if (tag == 177) {
         parse_cv:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &cv_)));
          set_has_cv();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(185)) goto parse_dv;
        break;
      }

      // optional double dv = 23;
      case 23: {
        if (tag == 185) {
         parse_dv:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &dv_)));
          set_has_dv();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(193)) goto parse_polyuratio;
        break;
      }

      // optional double polyuratio = 24;
      case 24: {
        if (tag == 193) {
         parse_polyuratio:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &polyuratio_)));
          set_has_polyuratio();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(201)) goto parse_polyvratio;
        break;
      }

      // optional double polyvratio = 25;
      case 25: {
        if (tag == 201) {
         parse_polyvratio:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &polyvratio_)));
          set_has_polyvratio();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iv.map.geodata)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iv.map.geodata)
  return false;
#undef DO_
}

void geodata::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iv.map.geodata)
  // optional uint32 index = 1;
  if (has_index()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->index(), output);
  }

  // required .iv.map.Point start = 2;
  if (has_start()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, *this->start_, output);
  }

  // required .iv.map.Point end = 3;
  if (has_end()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, *this->end_, output);
  }

  // optional double hdg = 4;
  if (has_hdg()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(4, this->hdg(), output);
  }

  // optional int32 index_start = 5;
  if (has_index_start()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->index_start(), output);
  }

  // optional int32 index_end = 6;
  if (has_index_end()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->index_end(), output);
  }

  // optional double off = 7;
  if (has_off()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(7, this->off(), output);
  }

  // optional double curvature = 8;
  if (has_curvature()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(8, this->curvature(), output);
  }

  // required .iv.map.geotype type = 9;
  if (has_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      9, this->type(), output);
  }

  // optional double s = 10;
  if (has_s()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(10, this->s(), output);
  }

  // optional .iv.map.Point curvcenter = 11;
  if (has_curvcenter()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      11, *this->curvcenter_, output);
  }

  // optional double mindis = 12;
  if (has_mindis()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(12, this->mindis(), output);
  }

  // optional double maxdis = 13;
  if (has_maxdis()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(13, this->maxdis(), output);
  }

  // optional double hdg_start = 14;
  if (has_hdg_start()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(14, this->hdg_start(), output);
  }

  // optional double hdg_end = 15;
  if (has_hdg_end()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(15, this->hdg_end(), output);
  }

  // optional double au = 16;
  if (has_au()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(16, this->au(), output);
  }

  // optional double bu = 17;
  if (has_bu()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(17, this->bu(), output);
  }

  // optional double cu = 18;
  if (has_cu()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(18, this->cu(), output);
  }

  // optional double du = 19;
  if (has_du()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(19, this->du(), output);
  }

  // optional double av = 20;
  if (has_av()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(20, this->av(), output);
  }

  // optional double bv = 21;
  if (has_bv()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(21, this->bv(), output);
  }

  // optional double cv = 22;
  if (has_cv()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(22, this->cv(), output);
  }

  // optional double dv = 23;
  if (has_dv()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(23, this->dv(), output);
  }

  // optional double polyuratio = 24;
  if (has_polyuratio()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(24, this->polyuratio(), output);
  }

  // optional double polyvratio = 25;
  if (has_polyvratio()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(25, this->polyvratio(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iv.map.geodata)
}

::google::protobuf::uint8* geodata::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iv.map.geodata)
  // optional uint32 index = 1;
  if (has_index()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->index(), target);
  }

  // required .iv.map.Point start = 2;
  if (has_start()) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageNoVirtualToArray(
        2, *this->start_, false, target);
  }

  // required .iv.map.Point end = 3;
  if (has_end()) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageNoVirtualToArray(
        3, *this->end_, false, target);
  }

  // optional double hdg = 4;
  if (has_hdg()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(4, this->hdg(), target);
  }

  // optional int32 index_start = 5;
  if (has_index_start()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->index_start(), target);
  }

  // optional int32 index_end = 6;
  if (has_index_end()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->index_end(), target);
  }

  // optional double off = 7;
  if (has_off()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(7, this->off(), target);
  }

  // optional double curvature = 8;
  if (has_curvature()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(8, this->curvature(), target);
  }

  // required .iv.map.geotype type = 9;
  if (has_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      9, this->type(), target);
  }

  // optional double s = 10;
  if (has_s()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(10, this->s(), target);
  }

  // optional .iv.map.Point curvcenter = 11;
  if (has_curvcenter()) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageNoVirtualToArray(
        11, *this->curvcenter_, false, target);
  }

  // optional double mindis = 12;
  if (has_mindis()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(12, this->mindis(), target);
  }

  // optional double maxdis = 13;
  if (has_maxdis()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(13, this->maxdis(), target);
  }

  // optional double hdg_start = 14;
  if (has_hdg_start()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(14, this->hdg_start(), target);
  }

  // optional double hdg_end = 15;
  if (has_hdg_end()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(15, this->hdg_end(), target);
  }

  // optional double au = 16;
  if (has_au()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(16, this->au(), target);
  }

  // optional double bu = 17;
  if (has_bu()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(17, this->bu(), target);
  }

  // optional double cu = 18;
  if (has_cu()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(18, this->cu(), target);
  }

  // optional double du = 19;
  if (has_du()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(19, this->du(), target);
  }

  // optional double av = 20;
  if (has_av()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(20, this->av(), target);
  }

  // optional double bv = 21;
  if (has_bv()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(21, this->bv(), target);
  }

  // optional double cv = 22;
  if (has_cv()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(22, this->cv(), target);
  }

  // optional double dv = 23;
  if (has_dv()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(23, this->dv(), target);
  }

  // optional double polyuratio = 24;
  if (has_polyuratio()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(24, this->polyuratio(), target);
  }

  // optional double polyvratio = 25;
  if (has_polyvratio()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(25, this->polyvratio(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iv.map.geodata)
  return target;
}

int geodata::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:iv.map.geodata)
  int total_size = 0;

  if (has_start()) {
    // required .iv.map.Point start = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        *this->start_);
  }

  if (has_end()) {
    // required .iv.map.Point end = 3;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        *this->end_);
  }

  if (has_type()) {
    // required .iv.map.geotype type = 9;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
  }

  return total_size;
}
int geodata::ByteSize() const {
// @@protoc_insertion_point(message_byte_size_start:iv.map.geodata)
  int total_size = 0;

  if (((_has_bits_[0] & 0x00000206) ^ 0x00000206) == 0) {  // All required fields are present.
    // required .iv.map.Point start = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        *this->start_);

    // required .iv.map.Point end = 3;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        *this->end_);

    // required .iv.map.geotype type = 9;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  if (_has_bits_[0 / 32] & 249u) {
    // optional uint32 index = 1;
    if (has_index()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->index());
    }

    // optional double hdg = 4;
    if (has_hdg()) {
      total_size += 1 + 8;
    }

    // optional int32 index_start = 5;
    if (has_index_start()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->index_start());
    }

    // optional int32 index_end = 6;
    if (has_index_end()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->index_end());
    }

    // optional double off = 7;
    if (has_off()) {
      total_size += 1 + 8;
    }

    // optional double curvature = 8;
    if (has_curvature()) {
      total_size += 1 + 8;
    }

  }
  if (_has_bits_[8 / 32] & 64768u) {
    // optional double s = 10;
    if (has_s()) {
      total_size += 1 + 8;
    }

    // optional .iv.map.Point curvcenter = 11;
    if (has_curvcenter()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->curvcenter_);
    }

    // optional double mindis = 12;
    if (has_mindis()) {
      total_size += 1 + 8;
    }

    // optional double maxdis = 13;
    if (has_maxdis()) {
      total_size += 1 + 8;
    }

    // optional double hdg_start = 14;
    if (has_hdg_start()) {
      total_size += 1 + 8;
    }

    // optional double hdg_end = 15;
    if (has_hdg_end()) {
      total_size += 1 + 8;
    }

    // optional double au = 16;
    if (has_au()) {
      total_size += 2 + 8;
    }

  }
  if (_has_bits_[16 / 32] & 16711680u) {
    // optional double bu = 17;
    if (has_bu()) {
      total_size += 2 + 8;
    }

    // optional double cu = 18;
    if (has_cu()) {
      total_size += 2 + 8;
    }

    // optional double du = 19;
    if (has_du()) {
      total_size += 2 + 8;
    }

    // optional double av = 20;
    if (has_av()) {
      total_size += 2 + 8;
    }

    // optional double bv = 21;
    if (has_bv()) {
      total_size += 2 + 8;
    }

    // optional double cv = 22;
    if (has_cv()) {
      total_size += 2 + 8;
    }

    // optional double dv = 23;
    if (has_dv()) {
      total_size += 2 + 8;
    }

    // optional double polyuratio = 24;
    if (has_polyuratio()) {
      total_size += 2 + 8;
    }

  }
  // optional double polyvratio = 25;
  if (has_polyvratio()) {
    total_size += 2 + 8;
  }

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void geodata::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:iv.map.geodata)
  if (GOOGLE_PREDICT_FALSE(&from == this)) {
    ::google::protobuf::internal::MergeFromFail(__FILE__, __LINE__);
  }
  const geodata* source = 
      ::google::protobuf::internal::DynamicCastToGenerated<const geodata>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:iv.map.geodata)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:iv.map.geodata)
    MergeFrom(*source);
  }
}

void geodata::MergeFrom(const geodata& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:iv.map.geodata)
  if (GOOGLE_PREDICT_FALSE(&from == this)) {
    ::google::protobuf::internal::MergeFromFail(__FILE__, __LINE__);
  }
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_index()) {
      set_index(from.index());
    }
    if (from.has_start()) {
      mutable_start()->::iv::map::Point::MergeFrom(from.start());
    }
    if (from.has_end()) {
      mutable_end()->::iv::map::Point::MergeFrom(from.end());
    }
    if (from.has_hdg()) {
      set_hdg(from.hdg());
    }
    if (from.has_index_start()) {
      set_index_start(from.index_start());
    }
    if (from.has_index_end()) {
      set_index_end(from.index_end());
    }
    if (from.has_off()) {
      set_off(from.off());
    }
    if (from.has_curvature()) {
      set_curvature(from.curvature());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_s()) {
      set_s(from.s());
    }
    if (from.has_type()) {
      set_type(from.type());
    }
    if (from.has_curvcenter()) {
      mutable_curvcenter()->::iv::map::Point::MergeFrom(from.curvcenter());
    }
    if (from.has_mindis()) {
      set_mindis(from.mindis());
    }
    if (from.has_maxdis()) {
      set_maxdis(from.maxdis());
    }
    if (from.has_hdg_start()) {
      set_hdg_start(from.hdg_start());
    }
    if (from.has_hdg_end()) {
      set_hdg_end(from.hdg_end());
    }
    if (from.has_au()) {
      set_au(from.au());
    }
  }
  if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) {
    if (from.has_bu()) {
      set_bu(from.bu());
    }
    if (from.has_cu()) {
      set_cu(from.cu());
    }
    if (from.has_du()) {
      set_du(from.du());
    }
    if (from.has_av()) {
      set_av(from.av());
    }
    if (from.has_bv()) {
      set_bv(from.bv());
    }
    if (from.has_cv()) {
      set_cv(from.cv());
    }
    if (from.has_dv()) {
      set_dv(from.dv());
    }
    if (from.has_polyuratio()) {
      set_polyuratio(from.polyuratio());
    }
  }
  if (from._has_bits_[24 / 32] & (0xffu << (24 % 32))) {
    if (from.has_polyvratio()) {
      set_polyvratio(from.polyvratio());
    }
  }
  if (from._internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
}

void geodata::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:iv.map.geodata)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void geodata::CopyFrom(const geodata& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:iv.map.geodata)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool geodata::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000206) != 0x00000206) return false;

  if (has_start()) {
    if (!this->start_->IsInitialized()) return false;
  }
  if (has_end()) {
    if (!this->end_->IsInitialized()) return false;
  }
  if (has_curvcenter()) {
    if (!this->curvcenter_->IsInitialized()) return false;
  }
  return true;
}

void geodata::Swap(geodata* other) {
  if (other == this) return;
  InternalSwap(other);
}
void geodata::InternalSwap(geodata* other) {
  std::swap(index_, other->index_);
  std::swap(start_, other->start_);
  std::swap(end_, other->end_);
  std::swap(hdg_, other->hdg_);
  std::swap(index_start_, other->index_start_);
  std::swap(index_end_, other->index_end_);
  std::swap(off_, other->off_);
  std::swap(curvature_, other->curvature_);
  std::swap(s_, other->s_);
  std::swap(type_, other->type_);
  std::swap(curvcenter_, other->curvcenter_);
  std::swap(mindis_, other->mindis_);
  std::swap(maxdis_, other->maxdis_);
  std::swap(hdg_start_, other->hdg_start_);
  std::swap(hdg_end_, other->hdg_end_);
  std::swap(au_, other->au_);
  std::swap(bu_, other->bu_);
  std::swap(cu_, other->cu_);
  std::swap(du_, other->du_);
  std::swap(av_, other->av_);
  std::swap(bv_, other->bv_);
  std::swap(cv_, other->cv_);
  std::swap(dv_, other->dv_);
  std::swap(polyuratio_, other->polyuratio_);
  std::swap(polyvratio_, other->polyvratio_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata geodata::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = geodata_descriptor_;
  metadata.reflection = geodata_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// geodata

// optional uint32 index = 1;
bool geodata::has_index() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void geodata::set_has_index() {
  _has_bits_[0] |= 0x00000001u;
}
void geodata::clear_has_index() {
  _has_bits_[0] &= ~0x00000001u;
}
void geodata::clear_index() {
  index_ = 0u;
  clear_has_index();
}
 ::google::protobuf::uint32 geodata::index() const {
  // @@protoc_insertion_point(field_get:iv.map.geodata.index)
  return index_;
}
 void geodata::set_index(::google::protobuf::uint32 value) {
  set_has_index();
  index_ = value;
  // @@protoc_insertion_point(field_set:iv.map.geodata.index)
}

// required .iv.map.Point start = 2;
bool geodata::has_start() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void geodata::set_has_start() {
  _has_bits_[0] |= 0x00000002u;
}
void geodata::clear_has_start() {
  _has_bits_[0] &= ~0x00000002u;
}
void geodata::clear_start() {
  if (start_ != NULL) start_->::iv::map::Point::Clear();
  clear_has_start();
}
const ::iv::map::Point& geodata::start() const {
  // @@protoc_insertion_point(field_get:iv.map.geodata.start)
  return start_ != NULL ? *start_ : *default_instance_->start_;
}
::iv::map::Point* geodata::mutable_start() {
  set_has_start();
  if (start_ == NULL) {
    start_ = new ::iv::map::Point;
  }
  // @@protoc_insertion_point(field_mutable:iv.map.geodata.start)
  return start_;
}
::iv::map::Point* geodata::release_start() {
  // @@protoc_insertion_point(field_release:iv.map.geodata.start)
  clear_has_start();
  ::iv::map::Point* temp = start_;
  start_ = NULL;
  return temp;
}
void geodata::set_allocated_start(::iv::map::Point* start) {
  delete start_;
  start_ = start;
  if (start) {
    set_has_start();
  } else {
    clear_has_start();
  }
  // @@protoc_insertion_point(field_set_allocated:iv.map.geodata.start)
}

// required .iv.map.Point end = 3;
bool geodata::has_end() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void geodata::set_has_end() {
  _has_bits_[0] |= 0x00000004u;
}
void geodata::clear_has_end() {
  _has_bits_[0] &= ~0x00000004u;
}
void geodata::clear_end() {
  if (end_ != NULL) end_->::iv::map::Point::Clear();
  clear_has_end();
}
const ::iv::map::Point& geodata::end() const {
  // @@protoc_insertion_point(field_get:iv.map.geodata.end)
  return end_ != NULL ? *end_ : *default_instance_->end_;
}
::iv::map::Point* geodata::mutable_end() {
  set_has_end();
  if (end_ == NULL) {
    end_ = new ::iv::map::Point;
  }
  // @@protoc_insertion_point(field_mutable:iv.map.geodata.end)
  return end_;
}
::iv::map::Point* geodata::release_end() {
  // @@protoc_insertion_point(field_release:iv.map.geodata.end)
  clear_has_end();
  ::iv::map::Point* temp = end_;
  end_ = NULL;
  return temp;
}
void geodata::set_allocated_end(::iv::map::Point* end) {
  delete end_;
  end_ = end;
  if (end) {
    set_has_end();
  } else {
    clear_has_end();
  }
  // @@protoc_insertion_point(field_set_allocated:iv.map.geodata.end)
}

// optional double hdg = 4;
bool geodata::has_hdg() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void geodata::set_has_hdg() {
  _has_bits_[0] |= 0x00000008u;
}
void geodata::clear_has_hdg() {
  _has_bits_[0] &= ~0x00000008u;
}
void geodata::clear_hdg() {
  hdg_ = 0;
  clear_has_hdg();
}
 double geodata::hdg() const {
  // @@protoc_insertion_point(field_get:iv.map.geodata.hdg)
  return hdg_;
}
 void geodata::set_hdg(double value) {
  set_has_hdg();
  hdg_ = value;
  // @@protoc_insertion_point(field_set:iv.map.geodata.hdg)
}

// optional int32 index_start = 5;
bool geodata::has_index_start() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void geodata::set_has_index_start() {
  _has_bits_[0] |= 0x00000010u;
}
void geodata::clear_has_index_start() {
  _has_bits_[0] &= ~0x00000010u;
}
void geodata::clear_index_start() {
  index_start_ = 0;
  clear_has_index_start();
}
 ::google::protobuf::int32 geodata::index_start() const {
  // @@protoc_insertion_point(field_get:iv.map.geodata.index_start)
  return index_start_;
}
 void geodata::set_index_start(::google::protobuf::int32 value) {
  set_has_index_start();
  index_start_ = value;
  // @@protoc_insertion_point(field_set:iv.map.geodata.index_start)
}

// optional int32 index_end = 6;
bool geodata::has_index_end() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void geodata::set_has_index_end() {
  _has_bits_[0] |= 0x00000020u;
}
void geodata::clear_has_index_end() {
  _has_bits_[0] &= ~0x00000020u;
}
void geodata::clear_index_end() {
  index_end_ = 0;
  clear_has_index_end();
}
 ::google::protobuf::int32 geodata::index_end() const {
  // @@protoc_insertion_point(field_get:iv.map.geodata.index_end)
  return index_end_;
}
 void geodata::set_index_end(::google::protobuf::int32 value) {
  set_has_index_end();
  index_end_ = value;
  // @@protoc_insertion_point(field_set:iv.map.geodata.index_end)
}

// optional double off = 7;
bool geodata::has_off() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
void geodata::set_has_off() {
  _has_bits_[0] |= 0x00000040u;
}
void geodata::clear_has_off() {
  _has_bits_[0] &= ~0x00000040u;
}
void geodata::clear_off() {
  off_ = 0;
  clear_has_off();
}
 double geodata::off() const {
  // @@protoc_insertion_point(field_get:iv.map.geodata.off)
  return off_;
}
 void geodata::set_off(double value) {
  set_has_off();
  off_ = value;
  // @@protoc_insertion_point(field_set:iv.map.geodata.off)
}

// optional double curvature = 8;
bool geodata::has_curvature() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
void geodata::set_has_curvature() {
  _has_bits_[0] |= 0x00000080u;
}
void geodata::clear_has_curvature() {
  _has_bits_[0] &= ~0x00000080u;
}
void geodata::clear_curvature() {
  curvature_ = 0;
  clear_has_curvature();
}
 double geodata::curvature() const {
  // @@protoc_insertion_point(field_get:iv.map.geodata.curvature)
  return curvature_;
}
 void geodata::set_curvature(double value) {
  set_has_curvature();
  curvature_ = value;
  // @@protoc_insertion_point(field_set:iv.map.geodata.curvature)
}

// optional double s = 10;
bool geodata::has_s() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
void geodata::set_has_s() {
  _has_bits_[0] |= 0x00000100u;
}
void geodata::clear_has_s() {
  _has_bits_[0] &= ~0x00000100u;
}
void geodata::clear_s() {
  s_ = 0;
  clear_has_s();
}
 double geodata::s() const {
  // @@protoc_insertion_point(field_get:iv.map.geodata.s)
  return s_;
}
 void geodata::set_s(double value) {
  set_has_s();
  s_ = value;
  // @@protoc_insertion_point(field_set:iv.map.geodata.s)
}

// required .iv.map.geotype type = 9;
bool geodata::has_type() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
void geodata::set_has_type() {
  _has_bits_[0] |= 0x00000200u;
}
void geodata::clear_has_type() {
  _has_bits_[0] &= ~0x00000200u;
}
void geodata::clear_type() {
  type_ = 0;
  clear_has_type();
}
 ::iv::map::geotype geodata::type() const {
  // @@protoc_insertion_point(field_get:iv.map.geodata.type)
  return static_cast< ::iv::map::geotype >(type_);
}
 void geodata::set_type(::iv::map::geotype value) {
  assert(::iv::map::geotype_IsValid(value));
  set_has_type();
  type_ = value;
  // @@protoc_insertion_point(field_set:iv.map.geodata.type)
}

// optional .iv.map.Point curvcenter = 11;
bool geodata::has_curvcenter() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
void geodata::set_has_curvcenter() {
  _has_bits_[0] |= 0x00000400u;
}
void geodata::clear_has_curvcenter() {
  _has_bits_[0] &= ~0x00000400u;
}
void geodata::clear_curvcenter() {
  if (curvcenter_ != NULL) curvcenter_->::iv::map::Point::Clear();
  clear_has_curvcenter();
}
const ::iv::map::Point& geodata::curvcenter() const {
  // @@protoc_insertion_point(field_get:iv.map.geodata.curvcenter)
  return curvcenter_ != NULL ? *curvcenter_ : *default_instance_->curvcenter_;
}
::iv::map::Point* geodata::mutable_curvcenter() {
  set_has_curvcenter();
  if (curvcenter_ == NULL) {
    curvcenter_ = new ::iv::map::Point;
  }
  // @@protoc_insertion_point(field_mutable:iv.map.geodata.curvcenter)
  return curvcenter_;
}
::iv::map::Point* geodata::release_curvcenter() {
  // @@protoc_insertion_point(field_release:iv.map.geodata.curvcenter)
  clear_has_curvcenter();
  ::iv::map::Point* temp = curvcenter_;
  curvcenter_ = NULL;
  return temp;
}
void geodata::set_allocated_curvcenter(::iv::map::Point* curvcenter) {
  delete curvcenter_;
  curvcenter_ = curvcenter;
  if (curvcenter) {
    set_has_curvcenter();
  } else {
    clear_has_curvcenter();
  }
  // @@protoc_insertion_point(field_set_allocated:iv.map.geodata.curvcenter)
}

// optional double mindis = 12;
bool geodata::has_mindis() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
void geodata::set_has_mindis() {
  _has_bits_[0] |= 0x00000800u;
}
void geodata::clear_has_mindis() {
  _has_bits_[0] &= ~0x00000800u;
}
void geodata::clear_mindis() {
  mindis_ = 0;
  clear_has_mindis();
}
 double geodata::mindis() const {
  // @@protoc_insertion_point(field_get:iv.map.geodata.mindis)
  return mindis_;
}
 void geodata::set_mindis(double value) {
  set_has_mindis();
  mindis_ = value;
  // @@protoc_insertion_point(field_set:iv.map.geodata.mindis)
}

// optional double maxdis = 13;
bool geodata::has_maxdis() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
void geodata::set_has_maxdis() {
  _has_bits_[0] |= 0x00001000u;
}
void geodata::clear_has_maxdis() {
  _has_bits_[0] &= ~0x00001000u;
}
void geodata::clear_maxdis() {
  maxdis_ = 0;
  clear_has_maxdis();
}
 double geodata::maxdis() const {
  // @@protoc_insertion_point(field_get:iv.map.geodata.maxdis)
  return maxdis_;
}
 void geodata::set_maxdis(double value) {
  set_has_maxdis();
  maxdis_ = value;
  // @@protoc_insertion_point(field_set:iv.map.geodata.maxdis)
}

// optional double hdg_start = 14;
bool geodata::has_hdg_start() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
void geodata::set_has_hdg_start() {
  _has_bits_[0] |= 0x00002000u;
}
void geodata::clear_has_hdg_start() {
  _has_bits_[0] &= ~0x00002000u;
}
void geodata::clear_hdg_start() {
  hdg_start_ = 0;
  clear_has_hdg_start();
}
 double geodata::hdg_start() const {
  // @@protoc_insertion_point(field_get:iv.map.geodata.hdg_start)
  return hdg_start_;
}
 void geodata::set_hdg_start(double value) {
  set_has_hdg_start();
  hdg_start_ = value;
  // @@protoc_insertion_point(field_set:iv.map.geodata.hdg_start)
}

// optional double hdg_end = 15;
bool geodata::has_hdg_end() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
void geodata::set_has_hdg_end() {
  _has_bits_[0] |= 0x00004000u;
}
void geodata::clear_has_hdg_end() {
  _has_bits_[0] &= ~0x00004000u;
}
void geodata::clear_hdg_end() {
  hdg_end_ = 0;
  clear_has_hdg_end();
}
 double geodata::hdg_end() const {
  // @@protoc_insertion_point(field_get:iv.map.geodata.hdg_end)
  return hdg_end_;
}
 void geodata::set_hdg_end(double value) {
  set_has_hdg_end();
  hdg_end_ = value;
  // @@protoc_insertion_point(field_set:iv.map.geodata.hdg_end)
}

// optional double au = 16;
bool geodata::has_au() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
void geodata::set_has_au() {
  _has_bits_[0] |= 0x00008000u;
}
void geodata::clear_has_au() {
  _has_bits_[0] &= ~0x00008000u;
}
void geodata::clear_au() {
  au_ = 0;
  clear_has_au();
}
 double geodata::au() const {
  // @@protoc_insertion_point(field_get:iv.map.geodata.au)
  return au_;
}
 void geodata::set_au(double value) {
  set_has_au();
  au_ = value;
  // @@protoc_insertion_point(field_set:iv.map.geodata.au)
}

// optional double bu = 17;
bool geodata::has_bu() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
void geodata::set_has_bu() {
  _has_bits_[0] |= 0x00010000u;
}
void geodata::clear_has_bu() {
  _has_bits_[0] &= ~0x00010000u;
}
void geodata::clear_bu() {
  bu_ = 0;
  clear_has_bu();
}
 double geodata::bu() const {
  // @@protoc_insertion_point(field_get:iv.map.geodata.bu)
  return bu_;
}
 void geodata::set_bu(double value) {
  set_has_bu();
  bu_ = value;
  // @@protoc_insertion_point(field_set:iv.map.geodata.bu)
}

// optional double cu = 18;
bool geodata::has_cu() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
void geodata::set_has_cu() {
  _has_bits_[0] |= 0x00020000u;
}
void geodata::clear_has_cu() {
  _has_bits_[0] &= ~0x00020000u;
}
void geodata::clear_cu() {
  cu_ = 0;
  clear_has_cu();
}
 double geodata::cu() const {
  // @@protoc_insertion_point(field_get:iv.map.geodata.cu)
  return cu_;
}
 void geodata::set_cu(double value) {
  set_has_cu();
  cu_ = value;
  // @@protoc_insertion_point(field_set:iv.map.geodata.cu)
}

// optional double du = 19;
bool geodata::has_du() const {
  return (_has_bits_[0] & 0x00040000u) != 0;
}
void geodata::set_has_du() {
  _has_bits_[0] |= 0x00040000u;
}
void geodata::clear_has_du() {
  _has_bits_[0] &= ~0x00040000u;
}
void geodata::clear_du() {
  du_ = 0;
  clear_has_du();
}
 double geodata::du() const {
  // @@protoc_insertion_point(field_get:iv.map.geodata.du)
  return du_;
}
 void geodata::set_du(double value) {
  set_has_du();
  du_ = value;
  // @@protoc_insertion_point(field_set:iv.map.geodata.du)
}

// optional double av = 20;
bool geodata::has_av() const {
  return (_has_bits_[0] & 0x00080000u) != 0;
}
void geodata::set_has_av() {
  _has_bits_[0] |= 0x00080000u;
}
void geodata::clear_has_av() {
  _has_bits_[0] &= ~0x00080000u;
}
void geodata::clear_av() {
  av_ = 0;
  clear_has_av();
}
 double geodata::av() const {
  // @@protoc_insertion_point(field_get:iv.map.geodata.av)
  return av_;
}
 void geodata::set_av(double value) {
  set_has_av();
  av_ = value;
  // @@protoc_insertion_point(field_set:iv.map.geodata.av)
}

// optional double bv = 21;
bool geodata::has_bv() const {
  return (_has_bits_[0] & 0x00100000u) != 0;
}
void geodata::set_has_bv() {
  _has_bits_[0] |= 0x00100000u;
}
void geodata::clear_has_bv() {
  _has_bits_[0] &= ~0x00100000u;
}
void geodata::clear_bv() {
  bv_ = 0;
  clear_has_bv();
}
 double geodata::bv() const {
  // @@protoc_insertion_point(field_get:iv.map.geodata.bv)
  return bv_;
}
 void geodata::set_bv(double value) {
  set_has_bv();
  bv_ = value;
  // @@protoc_insertion_point(field_set:iv.map.geodata.bv)
}

// optional double cv = 22;
bool geodata::has_cv() const {
  return (_has_bits_[0] & 0x00200000u) != 0;
}
void geodata::set_has_cv() {
  _has_bits_[0] |= 0x00200000u;
}
void geodata::clear_has_cv() {
  _has_bits_[0] &= ~0x00200000u;
}
void geodata::clear_cv() {
  cv_ = 0;
  clear_has_cv();
}
 double geodata::cv() const {
  // @@protoc_insertion_point(field_get:iv.map.geodata.cv)
  return cv_;
}
 void geodata::set_cv(double value) {
  set_has_cv();
  cv_ = value;
  // @@protoc_insertion_point(field_set:iv.map.geodata.cv)
}

// optional double dv = 23;
bool geodata::has_dv() const {
  return (_has_bits_[0] & 0x00400000u) != 0;
}
void geodata::set_has_dv() {
  _has_bits_[0] |= 0x00400000u;
}
void geodata::clear_has_dv() {
  _has_bits_[0] &= ~0x00400000u;
}
void geodata::clear_dv() {
  dv_ = 0;
  clear_has_dv();
}
 double geodata::dv() const {
  // @@protoc_insertion_point(field_get:iv.map.geodata.dv)
  return dv_;
}
 void geodata::set_dv(double value) {
  set_has_dv();
  dv_ = value;
  // @@protoc_insertion_point(field_set:iv.map.geodata.dv)
}

// optional double polyuratio = 24;
bool geodata::has_polyuratio() const {
  return (_has_bits_[0] & 0x00800000u) != 0;
}
void geodata::set_has_polyuratio() {
  _has_bits_[0] |= 0x00800000u;
}
void geodata::clear_has_polyuratio() {
  _has_bits_[0] &= ~0x00800000u;
}
void geodata::clear_polyuratio() {
  polyuratio_ = 0;
  clear_has_polyuratio();
}
 double geodata::polyuratio() const {
  // @@protoc_insertion_point(field_get:iv.map.geodata.polyuratio)
  return polyuratio_;
}
 void geodata::set_polyuratio(double value) {
  set_has_polyuratio();
  polyuratio_ = value;
  // @@protoc_insertion_point(field_set:iv.map.geodata.polyuratio)
}

// optional double polyvratio = 25;
bool geodata::has_polyvratio() const {
  return (_has_bits_[0] & 0x01000000u) != 0;
}
void geodata::set_has_polyvratio() {
  _has_bits_[0] |= 0x01000000u;
}
void geodata::clear_has_polyvratio() {
  _has_bits_[0] &= ~0x01000000u;
}
void geodata::clear_polyvratio() {
  polyvratio_ = 0;
  clear_has_polyvratio();
}
 double geodata::polyvratio() const {
  // @@protoc_insertion_point(field_get:iv.map.geodata.polyvratio)
  return polyvratio_;
}
 void geodata::set_polyvratio(double value) {
  set_has_polyvratio();
  polyvratio_ = value;
  // @@protoc_insertion_point(field_set:iv.map.geodata.polyvratio)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// @@protoc_insertion_point(namespace_scope)

}  // namespace map
}  // namespace iv

// @@protoc_insertion_point(global_scope)