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

#ifndef GOOGLE_PROTOBUF_INCLUDED_define_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_define_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 4000000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 4000000 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_define_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_define_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[8]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_define_2eproto;
class DetectResult;
class DetectResultDefaultTypeInternal;
extern DetectResultDefaultTypeInternal _DetectResult_default_instance_;
class LossResult;
class LossResultDefaultTypeInternal;
extern LossResultDefaultTypeInternal _LossResult_default_instance_;
class MeasureConfig;
class MeasureConfigDefaultTypeInternal;
extern MeasureConfigDefaultTypeInternal _MeasureConfig_default_instance_;
class MeasureLidar;
class MeasureLidarDefaultTypeInternal;
extern MeasureLidarDefaultTypeInternal _MeasureLidar_default_instance_;
class Region;
class RegionDefaultTypeInternal;
extern RegionDefaultTypeInternal _Region_default_instance_;
class RegionEtc;
class RegionEtcDefaultTypeInternal;
extern RegionEtcDefaultTypeInternal _RegionEtc_default_instance_;
class measure_info;
class measure_infoDefaultTypeInternal;
extern measure_infoDefaultTypeInternal _measure_info_default_instance_;
class measure_statu;
class measure_statuDefaultTypeInternal;
extern measure_statuDefaultTypeInternal _measure_statu_default_instance_;
PROTOBUF_NAMESPACE_OPEN
template<> ::DetectResult* Arena::CreateMaybeMessage<::DetectResult>(Arena*);
template<> ::LossResult* Arena::CreateMaybeMessage<::LossResult>(Arena*);
template<> ::MeasureConfig* Arena::CreateMaybeMessage<::MeasureConfig>(Arena*);
template<> ::MeasureLidar* Arena::CreateMaybeMessage<::MeasureLidar>(Arena*);
template<> ::Region* Arena::CreateMaybeMessage<::Region>(Arena*);
template<> ::RegionEtc* Arena::CreateMaybeMessage<::RegionEtc>(Arena*);
template<> ::measure_info* Arena::CreateMaybeMessage<::measure_info>(Arena*);
template<> ::measure_statu* Arena::CreateMaybeMessage<::measure_statu>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

enum Range_status : int {
  Range_correct = 0,
  Range_back = 1,
  Range_left = 2,
  Range_right = 4,
  Range_front = 8,
  Range_bottom = 16,
  Range_car_width = 32,
  Range_car_wheelbase = 64,
  Range_angle_anti_clock = 128,
  Range_angle_clock = 256,
  Range_steering_wheel_nozero = 512,
  Range_top = 1024,
  Range_car_moving = 2048
};
bool Range_status_IsValid(int value);
constexpr Range_status Range_status_MIN = Range_correct;
constexpr Range_status Range_status_MAX = Range_car_moving;
constexpr int Range_status_ARRAYSIZE = Range_status_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Range_status_descriptor();
template<typename T>
inline const std::string& Range_status_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Range_status>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Range_status_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Range_status_descriptor(), enum_t_value);
}
inline bool Range_status_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Range_status* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Range_status>(
    Range_status_descriptor(), name, value);
}
enum Ground_statu : int {
  ok = 0,
  Noise = 1,
  Nothing = 2,
  Car_border_reached = 3
};
bool Ground_statu_IsValid(int value);
constexpr Ground_statu Ground_statu_MIN = ok;
constexpr Ground_statu Ground_statu_MAX = Car_border_reached;
constexpr int Ground_statu_ARRAYSIZE = Ground_statu_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Ground_statu_descriptor();
template<typename T>
inline const std::string& Ground_statu_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Ground_statu>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Ground_statu_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Ground_statu_descriptor(), enum_t_value);
}
inline bool Ground_statu_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Ground_statu* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Ground_statu>(
    Ground_statu_descriptor(), name, value);
}
// ===================================================================

class LossResult PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:LossResult) */ {
 public:
  inline LossResult() : LossResult(nullptr) {}
  virtual ~LossResult();

  LossResult(const LossResult& from);
  LossResult(LossResult&& from) noexcept
    : LossResult() {
    *this = ::std::move(from);
  }

  inline LossResult& operator=(const LossResult& from) {
    CopyFrom(from);
    return *this;
  }
  inline LossResult& operator=(LossResult&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const LossResult& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LossResult* internal_default_instance() {
    return reinterpret_cast<const LossResult*>(
               &_LossResult_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(LossResult& a, LossResult& b) {
    a.Swap(&b);
  }
  inline void Swap(LossResult* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LossResult* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline LossResult* New() const final {
    return CreateMaybeMessage<LossResult>(nullptr);
  }

  LossResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LossResult>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const LossResult& from);
  void MergeFrom(const LossResult& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LossResult* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "LossResult";
  }
  protected:
  explicit LossResult(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_define_2eproto);
    return ::descriptor_table_define_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLfLossFieldNumber = 1,
    kRfLossFieldNumber = 2,
    kLbLossFieldNumber = 3,
    kRbLossFieldNumber = 4,
    kTotalAvgLossFieldNumber = 5,
  };
  // required float lf_loss = 1;
  bool has_lf_loss() const;
  private:
  bool _internal_has_lf_loss() const;
  public:
  void clear_lf_loss();
  float lf_loss() const;
  void set_lf_loss(float value);
  private:
  float _internal_lf_loss() const;
  void _internal_set_lf_loss(float value);
  public:

  // required float rf_loss = 2;
  bool has_rf_loss() const;
  private:
  bool _internal_has_rf_loss() const;
  public:
  void clear_rf_loss();
  float rf_loss() const;
  void set_rf_loss(float value);
  private:
  float _internal_rf_loss() const;
  void _internal_set_rf_loss(float value);
  public:

  // required float lb_loss = 3;
  bool has_lb_loss() const;
  private:
  bool _internal_has_lb_loss() const;
  public:
  void clear_lb_loss();
  float lb_loss() const;
  void set_lb_loss(float value);
  private:
  float _internal_lb_loss() const;
  void _internal_set_lb_loss(float value);
  public:

  // required float rb_loss = 4;
  bool has_rb_loss() const;
  private:
  bool _internal_has_rb_loss() const;
  public:
  void clear_rb_loss();
  float rb_loss() const;
  void set_rb_loss(float value);
  private:
  float _internal_rb_loss() const;
  void _internal_set_rb_loss(float value);
  public:

  // required float total_avg_loss = 5;
  bool has_total_avg_loss() const;
  private:
  bool _internal_has_total_avg_loss() const;
  public:
  void clear_total_avg_loss();
  float total_avg_loss() const;
  void set_total_avg_loss(float value);
  private:
  float _internal_total_avg_loss() const;
  void _internal_set_total_avg_loss(float value);
  public:

  // @@protoc_insertion_point(class_scope:LossResult)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  float lf_loss_;
  float rf_loss_;
  float lb_loss_;
  float rb_loss_;
  float total_avg_loss_;
  friend struct ::TableStruct_define_2eproto;
};
// -------------------------------------------------------------------

class DetectResult PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:DetectResult) */ {
 public:
  inline DetectResult() : DetectResult(nullptr) {}
  virtual ~DetectResult();

  DetectResult(const DetectResult& from);
  DetectResult(DetectResult&& from) noexcept
    : DetectResult() {
    *this = ::std::move(from);
  }

  inline DetectResult& operator=(const DetectResult& from) {
    CopyFrom(from);
    return *this;
  }
  inline DetectResult& operator=(DetectResult&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const DetectResult& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const DetectResult* internal_default_instance() {
    return reinterpret_cast<const DetectResult*>(
               &_DetectResult_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(DetectResult& a, DetectResult& b) {
    a.Swap(&b);
  }
  inline void Swap(DetectResult* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DetectResult* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline DetectResult* New() const final {
    return CreateMaybeMessage<DetectResult>(nullptr);
  }

  DetectResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DetectResult>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const DetectResult& from);
  void MergeFrom(const DetectResult& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DetectResult* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "DetectResult";
  }
  protected:
  explicit DetectResult(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_define_2eproto);
    return ::descriptor_table_define_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLossFieldNumber = 11,
    kCxFieldNumber = 1,
    kCyFieldNumber = 2,
    kThetaFieldNumber = 3,
    kWheelBaseFieldNumber = 4,
    kWidthFieldNumber = 5,
    kBodyWidthFieldNumber = 6,
    kFrontThetaFieldNumber = 7,
    kSingleWheelWidthFieldNumber = 8,
    kSingleWheelLengthFieldNumber = 9,
    kSuccessFieldNumber = 10,
  };
  // required .LossResult loss = 11;
  bool has_loss() const;
  private:
  bool _internal_has_loss() const;
  public:
  void clear_loss();
  const ::LossResult& loss() const;
  ::LossResult* release_loss();
  ::LossResult* mutable_loss();
  void set_allocated_loss(::LossResult* loss);
  private:
  const ::LossResult& _internal_loss() const;
  ::LossResult* _internal_mutable_loss();
  public:
  void unsafe_arena_set_allocated_loss(
      ::LossResult* loss);
  ::LossResult* unsafe_arena_release_loss();

  // required float cx = 1;
  bool has_cx() const;
  private:
  bool _internal_has_cx() const;
  public:
  void clear_cx();
  float cx() const;
  void set_cx(float value);
  private:
  float _internal_cx() const;
  void _internal_set_cx(float value);
  public:

  // required float cy = 2;
  bool has_cy() const;
  private:
  bool _internal_has_cy() const;
  public:
  void clear_cy();
  float cy() const;
  void set_cy(float value);
  private:
  float _internal_cy() const;
  void _internal_set_cy(float value);
  public:

  // required float theta = 3;
  bool has_theta() const;
  private:
  bool _internal_has_theta() const;
  public:
  void clear_theta();
  float theta() const;
  void set_theta(float value);
  private:
  float _internal_theta() const;
  void _internal_set_theta(float value);
  public:

  // required float wheel_base = 4;
  bool has_wheel_base() const;
  private:
  bool _internal_has_wheel_base() const;
  public:
  void clear_wheel_base();
  float wheel_base() const;
  void set_wheel_base(float value);
  private:
  float _internal_wheel_base() const;
  void _internal_set_wheel_base(float value);
  public:

  // required float width = 5;
  bool has_width() const;
  private:
  bool _internal_has_width() const;
  public:
  void clear_width();
  float width() const;
  void set_width(float value);
  private:
  float _internal_width() const;
  void _internal_set_width(float value);
  public:

  // required float body_width = 6;
  bool has_body_width() const;
  private:
  bool _internal_has_body_width() const;
  public:
  void clear_body_width();
  float body_width() const;
  void set_body_width(float value);
  private:
  float _internal_body_width() const;
  void _internal_set_body_width(float value);
  public:

  // required float front_theta = 7;
  bool has_front_theta() const;
  private:
  bool _internal_has_front_theta() const;
  public:
  void clear_front_theta();
  float front_theta() const;
  void set_front_theta(float value);
  private:
  float _internal_front_theta() const;
  void _internal_set_front_theta(float value);
  public:

  // required float single_wheel_width = 8;
  bool has_single_wheel_width() const;
  private:
  bool _internal_has_single_wheel_width() const;
  public:
  void clear_single_wheel_width();
  float single_wheel_width() const;
  void set_single_wheel_width(float value);
  private:
  float _internal_single_wheel_width() const;
  void _internal_set_single_wheel_width(float value);
  public:

  // required float single_wheel_length = 9;
  bool has_single_wheel_length() const;
  private:
  bool _internal_has_single_wheel_length() const;
  public:
  void clear_single_wheel_length();
  float single_wheel_length() const;
  void set_single_wheel_length(float value);
  private:
  float _internal_single_wheel_length() const;
  void _internal_set_single_wheel_length(float value);
  public:

  // required bool success = 10;
  bool has_success() const;
  private:
  bool _internal_has_success() const;
  public:
  void clear_success();
  bool success() const;
  void set_success(bool value);
  private:
  bool _internal_success() const;
  void _internal_set_success(bool value);
  public:

  // @@protoc_insertion_point(class_scope:DetectResult)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::LossResult* loss_;
  float cx_;
  float cy_;
  float theta_;
  float wheel_base_;
  float width_;
  float body_width_;
  float front_theta_;
  float single_wheel_width_;
  float single_wheel_length_;
  bool success_;
  friend struct ::TableStruct_define_2eproto;
};
// -------------------------------------------------------------------

class RegionEtc PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:RegionEtc) */ {
 public:
  inline RegionEtc() : RegionEtc(nullptr) {}
  virtual ~RegionEtc();

  RegionEtc(const RegionEtc& from);
  RegionEtc(RegionEtc&& from) noexcept
    : RegionEtc() {
    *this = ::std::move(from);
  }

  inline RegionEtc& operator=(const RegionEtc& from) {
    CopyFrom(from);
    return *this;
  }
  inline RegionEtc& operator=(RegionEtc&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const RegionEtc& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RegionEtc* internal_default_instance() {
    return reinterpret_cast<const RegionEtc*>(
               &_RegionEtc_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(RegionEtc& a, RegionEtc& b) {
    a.Swap(&b);
  }
  inline void Swap(RegionEtc* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RegionEtc* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline RegionEtc* New() const final {
    return CreateMaybeMessage<RegionEtc>(nullptr);
  }

  RegionEtc* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RegionEtc>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RegionEtc& from);
  void MergeFrom(const RegionEtc& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RegionEtc* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "RegionEtc";
  }
  protected:
  explicit RegionEtc(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_define_2eproto);
    return ::descriptor_table_define_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMaxxFieldNumber = 1,
    kMinxFieldNumber = 2,
    kMaxyFieldNumber = 3,
    kMinyFieldNumber = 4,
    kMaxzFieldNumber = 5,
    kMinzFieldNumber = 6,
  };
  // required double maxx = 1;
  bool has_maxx() const;
  private:
  bool _internal_has_maxx() const;
  public:
  void clear_maxx();
  double maxx() const;
  void set_maxx(double value);
  private:
  double _internal_maxx() const;
  void _internal_set_maxx(double value);
  public:

  // required double minx = 2;
  bool has_minx() const;
  private:
  bool _internal_has_minx() const;
  public:
  void clear_minx();
  double minx() const;
  void set_minx(double value);
  private:
  double _internal_minx() const;
  void _internal_set_minx(double value);
  public:

  // required double maxy = 3;
  bool has_maxy() const;
  private:
  bool _internal_has_maxy() const;
  public:
  void clear_maxy();
  double maxy() const;
  void set_maxy(double value);
  private:
  double _internal_maxy() const;
  void _internal_set_maxy(double value);
  public:

  // required double miny = 4;
  bool has_miny() const;
  private:
  bool _internal_has_miny() const;
  public:
  void clear_miny();
  double miny() const;
  void set_miny(double value);
  private:
  double _internal_miny() const;
  void _internal_set_miny(double value);
  public:

  // required double maxz = 5;
  bool has_maxz() const;
  private:
  bool _internal_has_maxz() const;
  public:
  void clear_maxz();
  double maxz() const;
  void set_maxz(double value);
  private:
  double _internal_maxz() const;
  void _internal_set_maxz(double value);
  public:

  // required double minz = 6;
  bool has_minz() const;
  private:
  bool _internal_has_minz() const;
  public:
  void clear_minz();
  double minz() const;
  void set_minz(double value);
  private:
  double _internal_minz() const;
  void _internal_set_minz(double value);
  public:

  // @@protoc_insertion_point(class_scope:RegionEtc)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  double maxx_;
  double minx_;
  double maxy_;
  double miny_;
  double maxz_;
  double minz_;
  friend struct ::TableStruct_define_2eproto;
};
// -------------------------------------------------------------------

class Region PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:Region) */ {
 public:
  inline Region() : Region(nullptr) {}
  virtual ~Region();

  Region(const Region& from);
  Region(Region&& from) noexcept
    : Region() {
    *this = ::std::move(from);
  }

  inline Region& operator=(const Region& from) {
    CopyFrom(from);
    return *this;
  }
  inline Region& operator=(Region&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Region& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Region* internal_default_instance() {
    return reinterpret_cast<const Region*>(
               &_Region_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(Region& a, Region& b) {
    a.Swap(&b);
  }
  inline void Swap(Region* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Region* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline Region* New() const final {
    return CreateMaybeMessage<Region>(nullptr);
  }

  Region* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Region>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Region& from);
  void MergeFrom(const Region& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Region* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Region";
  }
  protected:
  explicit Region(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_define_2eproto);
    return ::descriptor_table_define_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCutRegionFieldNumber = 1,
    kTurnplateCxFieldNumber = 2,
    kTurnplateCyFieldNumber = 3,
    kBorderMinxFieldNumber = 4,
    kBorderMaxxFieldNumber = 5,
    kPlcOffsetxFieldNumber = 6,
    kPlcOffsetyFieldNumber = 7,
    kPlcOffsetDegreeFieldNumber = 8,
    kPlcBorderMinyFieldNumber = 9,
    kPlcBorderMaxyFieldNumber = 10,
    kCarMinWidthFieldNumber = 11,
    kCarMaxWidthFieldNumber = 12,
    kCarMinWheelbaseFieldNumber = 13,
    kCarMaxWheelbaseFieldNumber = 14,
    kTurnplateAngleMinFieldNumber = 15,
    kTurnplateAngleMaxFieldNumber = 16,
    kTurnplateAngleLimitAntiClockwiseFieldNumber = 17,
    kTurnplateAngleLimitClockwiseFieldNumber = 18,
  };
  // required .RegionEtc cut_region = 1;
  bool has_cut_region() const;
  private:
  bool _internal_has_cut_region() const;
  public:
  void clear_cut_region();
  const ::RegionEtc& cut_region() const;
  ::RegionEtc* release_cut_region();
  ::RegionEtc* mutable_cut_region();
  void set_allocated_cut_region(::RegionEtc* cut_region);
  private:
  const ::RegionEtc& _internal_cut_region() const;
  ::RegionEtc* _internal_mutable_cut_region();
  public:
  void unsafe_arena_set_allocated_cut_region(
      ::RegionEtc* cut_region);
  ::RegionEtc* unsafe_arena_release_cut_region();

  // required float turnplate_cx = 2;
  bool has_turnplate_cx() const;
  private:
  bool _internal_has_turnplate_cx() const;
  public:
  void clear_turnplate_cx();
  float turnplate_cx() const;
  void set_turnplate_cx(float value);
  private:
  float _internal_turnplate_cx() const;
  void _internal_set_turnplate_cx(float value);
  public:

  // required float turnplate_cy = 3;
  bool has_turnplate_cy() const;
  private:
  bool _internal_has_turnplate_cy() const;
  public:
  void clear_turnplate_cy();
  float turnplate_cy() const;
  void set_turnplate_cy(float value);
  private:
  float _internal_turnplate_cy() const;
  void _internal_set_turnplate_cy(float value);
  public:

  // required float border_minx = 4;
  bool has_border_minx() const;
  private:
  bool _internal_has_border_minx() const;
  public:
  void clear_border_minx();
  float border_minx() const;
  void set_border_minx(float value);
  private:
  float _internal_border_minx() const;
  void _internal_set_border_minx(float value);
  public:

  // required float border_maxx = 5;
  bool has_border_maxx() const;
  private:
  bool _internal_has_border_maxx() const;
  public:
  void clear_border_maxx();
  float border_maxx() const;
  void set_border_maxx(float value);
  private:
  float _internal_border_maxx() const;
  void _internal_set_border_maxx(float value);
  public:

  // required float plc_offsetx = 6;
  bool has_plc_offsetx() const;
  private:
  bool _internal_has_plc_offsetx() const;
  public:
  void clear_plc_offsetx();
  float plc_offsetx() const;
  void set_plc_offsetx(float value);
  private:
  float _internal_plc_offsetx() const;
  void _internal_set_plc_offsetx(float value);
  public:

  // required float plc_offsety = 7;
  bool has_plc_offsety() const;
  private:
  bool _internal_has_plc_offsety() const;
  public:
  void clear_plc_offsety();
  float plc_offsety() const;
  void set_plc_offsety(float value);
  private:
  float _internal_plc_offsety() const;
  void _internal_set_plc_offsety(float value);
  public:

  // required float plc_offset_degree = 8;
  bool has_plc_offset_degree() const;
  private:
  bool _internal_has_plc_offset_degree() const;
  public:
  void clear_plc_offset_degree();
  float plc_offset_degree() const;
  void set_plc_offset_degree(float value);
  private:
  float _internal_plc_offset_degree() const;
  void _internal_set_plc_offset_degree(float value);
  public:

  // required float plc_border_miny = 9;
  bool has_plc_border_miny() const;
  private:
  bool _internal_has_plc_border_miny() const;
  public:
  void clear_plc_border_miny();
  float plc_border_miny() const;
  void set_plc_border_miny(float value);
  private:
  float _internal_plc_border_miny() const;
  void _internal_set_plc_border_miny(float value);
  public:

  // required float plc_border_maxy = 10;
  bool has_plc_border_maxy() const;
  private:
  bool _internal_has_plc_border_maxy() const;
  public:
  void clear_plc_border_maxy();
  float plc_border_maxy() const;
  void set_plc_border_maxy(float value);
  private:
  float _internal_plc_border_maxy() const;
  void _internal_set_plc_border_maxy(float value);
  public:

  // required float car_min_width = 11;
  bool has_car_min_width() const;
  private:
  bool _internal_has_car_min_width() const;
  public:
  void clear_car_min_width();
  float car_min_width() const;
  void set_car_min_width(float value);
  private:
  float _internal_car_min_width() const;
  void _internal_set_car_min_width(float value);
  public:

  // required float car_max_width = 12;
  bool has_car_max_width() const;
  private:
  bool _internal_has_car_max_width() const;
  public:
  void clear_car_max_width();
  float car_max_width() const;
  void set_car_max_width(float value);
  private:
  float _internal_car_max_width() const;
  void _internal_set_car_max_width(float value);
  public:

  // required float car_min_wheelbase = 13;
  bool has_car_min_wheelbase() const;
  private:
  bool _internal_has_car_min_wheelbase() const;
  public:
  void clear_car_min_wheelbase();
  float car_min_wheelbase() const;
  void set_car_min_wheelbase(float value);
  private:
  float _internal_car_min_wheelbase() const;
  void _internal_set_car_min_wheelbase(float value);
  public:

  // required float car_max_wheelbase = 14;
  bool has_car_max_wheelbase() const;
  private:
  bool _internal_has_car_max_wheelbase() const;
  public:
  void clear_car_max_wheelbase();
  float car_max_wheelbase() const;
  void set_car_max_wheelbase(float value);
  private:
  float _internal_car_max_wheelbase() const;
  void _internal_set_car_max_wheelbase(float value);
  public:

  // required float turnplate_angle_min = 15;
  bool has_turnplate_angle_min() const;
  private:
  bool _internal_has_turnplate_angle_min() const;
  public:
  void clear_turnplate_angle_min();
  float turnplate_angle_min() const;
  void set_turnplate_angle_min(float value);
  private:
  float _internal_turnplate_angle_min() const;
  void _internal_set_turnplate_angle_min(float value);
  public:

  // required float turnplate_angle_max = 16;
  bool has_turnplate_angle_max() const;
  private:
  bool _internal_has_turnplate_angle_max() const;
  public:
  void clear_turnplate_angle_max();
  float turnplate_angle_max() const;
  void set_turnplate_angle_max(float value);
  private:
  float _internal_turnplate_angle_max() const;
  void _internal_set_turnplate_angle_max(float value);
  public:

  // required float turnplate_angle_limit_anti_clockwise = 17;
  bool has_turnplate_angle_limit_anti_clockwise() const;
  private:
  bool _internal_has_turnplate_angle_limit_anti_clockwise() const;
  public:
  void clear_turnplate_angle_limit_anti_clockwise();
  float turnplate_angle_limit_anti_clockwise() const;
  void set_turnplate_angle_limit_anti_clockwise(float value);
  private:
  float _internal_turnplate_angle_limit_anti_clockwise() const;
  void _internal_set_turnplate_angle_limit_anti_clockwise(float value);
  public:

  // required float turnplate_angle_limit_clockwise = 18;
  bool has_turnplate_angle_limit_clockwise() const;
  private:
  bool _internal_has_turnplate_angle_limit_clockwise() const;
  public:
  void clear_turnplate_angle_limit_clockwise();
  float turnplate_angle_limit_clockwise() const;
  void set_turnplate_angle_limit_clockwise(float value);
  private:
  float _internal_turnplate_angle_limit_clockwise() const;
  void _internal_set_turnplate_angle_limit_clockwise(float value);
  public:

  // @@protoc_insertion_point(class_scope:Region)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::RegionEtc* cut_region_;
  float turnplate_cx_;
  float turnplate_cy_;
  float border_minx_;
  float border_maxx_;
  float plc_offsetx_;
  float plc_offsety_;
  float plc_offset_degree_;
  float plc_border_miny_;
  float plc_border_maxy_;
  float car_min_width_;
  float car_max_width_;
  float car_min_wheelbase_;
  float car_max_wheelbase_;
  float turnplate_angle_min_;
  float turnplate_angle_max_;
  float turnplate_angle_limit_anti_clockwise_;
  float turnplate_angle_limit_clockwise_;
  friend struct ::TableStruct_define_2eproto;
};
// -------------------------------------------------------------------

class MeasureLidar PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MeasureLidar) */ {
 public:
  inline MeasureLidar() : MeasureLidar(nullptr) {}
  virtual ~MeasureLidar();

  MeasureLidar(const MeasureLidar& from);
  MeasureLidar(MeasureLidar&& from) noexcept
    : MeasureLidar() {
    *this = ::std::move(from);
  }

  inline MeasureLidar& operator=(const MeasureLidar& from) {
    CopyFrom(from);
    return *this;
  }
  inline MeasureLidar& operator=(MeasureLidar&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const MeasureLidar& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MeasureLidar* internal_default_instance() {
    return reinterpret_cast<const MeasureLidar*>(
               &_MeasureLidar_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(MeasureLidar& a, MeasureLidar& b) {
    a.Swap(&b);
  }
  inline void Swap(MeasureLidar* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MeasureLidar* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline MeasureLidar* New() const final {
    return CreateMaybeMessage<MeasureLidar>(nullptr);
  }

  MeasureLidar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MeasureLidar>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const MeasureLidar& from);
  void MergeFrom(const MeasureLidar& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MeasureLidar* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "MeasureLidar";
  }
  protected:
  explicit MeasureLidar(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_define_2eproto);
    return ::descriptor_table_define_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLidarTopicFieldNumber = 5,
    kMeasureTopicFieldNumber = 1,
    kRegionFieldNumber = 2,
  };
  // repeated string lidarTopic = 5;
  int lidartopic_size() const;
  private:
  int _internal_lidartopic_size() const;
  public:
  void clear_lidartopic();
  const std::string& lidartopic(int index) const;
  std::string* mutable_lidartopic(int index);
  void set_lidartopic(int index, const std::string& value);
  void set_lidartopic(int index, std::string&& value);
  void set_lidartopic(int index, const char* value);
  void set_lidartopic(int index, const char* value, size_t size);
  std::string* add_lidartopic();
  void add_lidartopic(const std::string& value);
  void add_lidartopic(std::string&& value);
  void add_lidartopic(const char* value);
  void add_lidartopic(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& lidartopic() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_lidartopic();
  private:
  const std::string& _internal_lidartopic(int index) const;
  std::string* _internal_add_lidartopic();
  public:

  // required string measureTopic = 1;
  bool has_measuretopic() const;
  private:
  bool _internal_has_measuretopic() const;
  public:
  void clear_measuretopic();
  const std::string& measuretopic() const;
  void set_measuretopic(const std::string& value);
  void set_measuretopic(std::string&& value);
  void set_measuretopic(const char* value);
  void set_measuretopic(const char* value, size_t size);
  std::string* mutable_measuretopic();
  std::string* release_measuretopic();
  void set_allocated_measuretopic(std::string* measuretopic);
  private:
  const std::string& _internal_measuretopic() const;
  void _internal_set_measuretopic(const std::string& value);
  std::string* _internal_mutable_measuretopic();
  public:

  // required .Region region = 2;
  bool has_region() const;
  private:
  bool _internal_has_region() const;
  public:
  void clear_region();
  const ::Region& region() const;
  ::Region* release_region();
  ::Region* mutable_region();
  void set_allocated_region(::Region* region);
  private:
  const ::Region& _internal_region() const;
  ::Region* _internal_mutable_region();
  public:
  void unsafe_arena_set_allocated_region(
      ::Region* region);
  ::Region* unsafe_arena_release_region();

  // @@protoc_insertion_point(class_scope:MeasureLidar)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> lidartopic_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr measuretopic_;
  ::Region* region_;
  friend struct ::TableStruct_define_2eproto;
};
// -------------------------------------------------------------------

class MeasureConfig PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:MeasureConfig) */ {
 public:
  inline MeasureConfig() : MeasureConfig(nullptr) {}
  virtual ~MeasureConfig();

  MeasureConfig(const MeasureConfig& from);
  MeasureConfig(MeasureConfig&& from) noexcept
    : MeasureConfig() {
    *this = ::std::move(from);
  }

  inline MeasureConfig& operator=(const MeasureConfig& from) {
    CopyFrom(from);
    return *this;
  }
  inline MeasureConfig& operator=(MeasureConfig&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const MeasureConfig& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MeasureConfig* internal_default_instance() {
    return reinterpret_cast<const MeasureConfig*>(
               &_MeasureConfig_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(MeasureConfig& a, MeasureConfig& b) {
    a.Swap(&b);
  }
  inline void Swap(MeasureConfig* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MeasureConfig* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline MeasureConfig* New() const final {
    return CreateMaybeMessage<MeasureConfig>(nullptr);
  }

  MeasureConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MeasureConfig>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const MeasureConfig& from);
  void MergeFrom(const MeasureConfig& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MeasureConfig* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "MeasureConfig";
  }
  protected:
  explicit MeasureConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_define_2eproto);
    return ::descriptor_table_define_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMeasuresFieldNumber = 5,
    kSendTopicsFieldNumber = 1,
    kLidarTopicsFieldNumber = 2,
  };
  // repeated .MeasureLidar measures = 5;
  int measures_size() const;
  private:
  int _internal_measures_size() const;
  public:
  void clear_measures();
  ::MeasureLidar* mutable_measures(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MeasureLidar >*
      mutable_measures();
  private:
  const ::MeasureLidar& _internal_measures(int index) const;
  ::MeasureLidar* _internal_add_measures();
  public:
  const ::MeasureLidar& measures(int index) const;
  ::MeasureLidar* add_measures();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MeasureLidar >&
      measures() const;

  // required string sendTopics = 1;
  bool has_sendtopics() const;
  private:
  bool _internal_has_sendtopics() const;
  public:
  void clear_sendtopics();
  const std::string& sendtopics() const;
  void set_sendtopics(const std::string& value);
  void set_sendtopics(std::string&& value);
  void set_sendtopics(const char* value);
  void set_sendtopics(const char* value, size_t size);
  std::string* mutable_sendtopics();
  std::string* release_sendtopics();
  void set_allocated_sendtopics(std::string* sendtopics);
  private:
  const std::string& _internal_sendtopics() const;
  void _internal_set_sendtopics(const std::string& value);
  std::string* _internal_mutable_sendtopics();
  public:

  // required string lidarTopics = 2;
  bool has_lidartopics() const;
  private:
  bool _internal_has_lidartopics() const;
  public:
  void clear_lidartopics();
  const std::string& lidartopics() const;
  void set_lidartopics(const std::string& value);
  void set_lidartopics(std::string&& value);
  void set_lidartopics(const char* value);
  void set_lidartopics(const char* value, size_t size);
  std::string* mutable_lidartopics();
  std::string* release_lidartopics();
  void set_allocated_lidartopics(std::string* lidartopics);
  private:
  const std::string& _internal_lidartopics() const;
  void _internal_set_lidartopics(const std::string& value);
  std::string* _internal_mutable_lidartopics();
  public:

  // @@protoc_insertion_point(class_scope:MeasureConfig)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MeasureLidar > measures_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sendtopics_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr lidartopics_;
  friend struct ::TableStruct_define_2eproto;
};
// -------------------------------------------------------------------

class measure_info PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:measure_info) */ {
 public:
  inline measure_info() : measure_info(nullptr) {}
  virtual ~measure_info();

  measure_info(const measure_info& from);
  measure_info(measure_info&& from) noexcept
    : measure_info() {
    *this = ::std::move(from);
  }

  inline measure_info& operator=(const measure_info& from) {
    CopyFrom(from);
    return *this;
  }
  inline measure_info& operator=(measure_info&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const measure_info& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const measure_info* internal_default_instance() {
    return reinterpret_cast<const measure_info*>(
               &_measure_info_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(measure_info& a, measure_info& b) {
    a.Swap(&b);
  }
  inline void Swap(measure_info* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(measure_info* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline measure_info* New() const final {
    return CreateMaybeMessage<measure_info>(nullptr);
  }

  measure_info* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<measure_info>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const measure_info& from);
  void MergeFrom(const measure_info& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(measure_info* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "measure_info";
  }
  protected:
  explicit measure_info(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_define_2eproto);
    return ::descriptor_table_define_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCxFieldNumber = 1,
    kCyFieldNumber = 2,
    kThetaFieldNumber = 3,
    kLengthFieldNumber = 4,
    kWidthFieldNumber = 5,
    kHeightFieldNumber = 6,
    kWheelbaseFieldNumber = 7,
    kFrontThetaFieldNumber = 8,
    kBorderStatuFieldNumber = 9,
    kGroundStatusFieldNumber = 10,
    kIsStopFieldNumber = 11,
  };
  // required float cx = 1 [default = 0];
  bool has_cx() const;
  private:
  bool _internal_has_cx() const;
  public:
  void clear_cx();
  float cx() const;
  void set_cx(float value);
  private:
  float _internal_cx() const;
  void _internal_set_cx(float value);
  public:

  // required float cy = 2 [default = 0];
  bool has_cy() const;
  private:
  bool _internal_has_cy() const;
  public:
  void clear_cy();
  float cy() const;
  void set_cy(float value);
  private:
  float _internal_cy() const;
  void _internal_set_cy(float value);
  public:

  // required float theta = 3 [default = 0];
  bool has_theta() const;
  private:
  bool _internal_has_theta() const;
  public:
  void clear_theta();
  float theta() const;
  void set_theta(float value);
  private:
  float _internal_theta() const;
  void _internal_set_theta(float value);
  public:

  // required float length = 4 [default = 0];
  bool has_length() const;
  private:
  bool _internal_has_length() const;
  public:
  void clear_length();
  float length() const;
  void set_length(float value);
  private:
  float _internal_length() const;
  void _internal_set_length(float value);
  public:

  // required float width = 5 [default = 0];
  bool has_width() const;
  private:
  bool _internal_has_width() const;
  public:
  void clear_width();
  float width() const;
  void set_width(float value);
  private:
  float _internal_width() const;
  void _internal_set_width(float value);
  public:

  // required float height = 6 [default = 0];
  bool has_height() const;
  private:
  bool _internal_has_height() const;
  public:
  void clear_height();
  float height() const;
  void set_height(float value);
  private:
  float _internal_height() const;
  void _internal_set_height(float value);
  public:

  // required float wheelbase = 7 [default = 0];
  bool has_wheelbase() const;
  private:
  bool _internal_has_wheelbase() const;
  public:
  void clear_wheelbase();
  float wheelbase() const;
  void set_wheelbase(float value);
  private:
  float _internal_wheelbase() const;
  void _internal_set_wheelbase(float value);
  public:

  // required float front_theta = 8 [default = 0];
  bool has_front_theta() const;
  private:
  bool _internal_has_front_theta() const;
  public:
  void clear_front_theta();
  float front_theta() const;
  void set_front_theta(float value);
  private:
  float _internal_front_theta() const;
  void _internal_set_front_theta(float value);
  public:

  // required int32 border_statu = 9 [default = 0];
  bool has_border_statu() const;
  private:
  bool _internal_has_border_statu() const;
  public:
  void clear_border_statu();
  ::PROTOBUF_NAMESPACE_ID::int32 border_statu() const;
  void set_border_statu(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_border_statu() const;
  void _internal_set_border_statu(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // required int32 ground_status = 10 [default = 1];
  bool has_ground_status() const;
  private:
  bool _internal_has_ground_status() const;
  public:
  void clear_ground_status();
  ::PROTOBUF_NAMESPACE_ID::int32 ground_status() const;
  void set_ground_status(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_ground_status() const;
  void _internal_set_ground_status(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // required int32 is_stop = 11 [default = 2];
  bool has_is_stop() const;
  private:
  bool _internal_has_is_stop() const;
  public:
  void clear_is_stop();
  ::PROTOBUF_NAMESPACE_ID::int32 is_stop() const;
  void set_is_stop(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_is_stop() const;
  void _internal_set_is_stop(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:measure_info)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  float cx_;
  float cy_;
  float theta_;
  float length_;
  float width_;
  float height_;
  float wheelbase_;
  float front_theta_;
  ::PROTOBUF_NAMESPACE_ID::int32 border_statu_;
  ::PROTOBUF_NAMESPACE_ID::int32 ground_status_;
  ::PROTOBUF_NAMESPACE_ID::int32 is_stop_;
  friend struct ::TableStruct_define_2eproto;
};
// -------------------------------------------------------------------

class measure_statu PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:measure_statu) */ {
 public:
  inline measure_statu() : measure_statu(nullptr) {}
  virtual ~measure_statu();

  measure_statu(const measure_statu& from);
  measure_statu(measure_statu&& from) noexcept
    : measure_statu() {
    *this = ::std::move(from);
  }

  inline measure_statu& operator=(const measure_statu& from) {
    CopyFrom(from);
    return *this;
  }
  inline measure_statu& operator=(measure_statu&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const measure_statu& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const measure_statu* internal_default_instance() {
    return reinterpret_cast<const measure_statu*>(
               &_measure_statu_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(measure_statu& a, measure_statu& b) {
    a.Swap(&b);
  }
  inline void Swap(measure_statu* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(measure_statu* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline measure_statu* New() const final {
    return CreateMaybeMessage<measure_statu>(nullptr);
  }

  measure_statu* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<measure_statu>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const measure_statu& from);
  void MergeFrom(const measure_statu& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(measure_statu* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "measure_statu";
  }
  protected:
  explicit measure_statu(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_define_2eproto);
    return ::descriptor_table_define_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kInfoFieldNumber = 1,
  };
  // required .measure_info info = 1;
  bool has_info() const;
  private:
  bool _internal_has_info() const;
  public:
  void clear_info();
  const ::measure_info& info() const;
  ::measure_info* release_info();
  ::measure_info* mutable_info();
  void set_allocated_info(::measure_info* info);
  private:
  const ::measure_info& _internal_info() const;
  ::measure_info* _internal_mutable_info();
  public:
  void unsafe_arena_set_allocated_info(
      ::measure_info* info);
  ::measure_info* unsafe_arena_release_info();

  // @@protoc_insertion_point(class_scope:measure_statu)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::measure_info* info_;
  friend struct ::TableStruct_define_2eproto;
};
// ===================================================================


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

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// LossResult

// required float lf_loss = 1;
inline bool LossResult::_internal_has_lf_loss() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool LossResult::has_lf_loss() const {
  return _internal_has_lf_loss();
}
inline void LossResult::clear_lf_loss() {
  lf_loss_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline float LossResult::_internal_lf_loss() const {
  return lf_loss_;
}
inline float LossResult::lf_loss() const {
  // @@protoc_insertion_point(field_get:LossResult.lf_loss)
  return _internal_lf_loss();
}
inline void LossResult::_internal_set_lf_loss(float value) {
  _has_bits_[0] |= 0x00000001u;
  lf_loss_ = value;
}
inline void LossResult::set_lf_loss(float value) {
  _internal_set_lf_loss(value);
  // @@protoc_insertion_point(field_set:LossResult.lf_loss)
}

// required float rf_loss = 2;
inline bool LossResult::_internal_has_rf_loss() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool LossResult::has_rf_loss() const {
  return _internal_has_rf_loss();
}
inline void LossResult::clear_rf_loss() {
  rf_loss_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline float LossResult::_internal_rf_loss() const {
  return rf_loss_;
}
inline float LossResult::rf_loss() const {
  // @@protoc_insertion_point(field_get:LossResult.rf_loss)
  return _internal_rf_loss();
}
inline void LossResult::_internal_set_rf_loss(float value) {
  _has_bits_[0] |= 0x00000002u;
  rf_loss_ = value;
}
inline void LossResult::set_rf_loss(float value) {
  _internal_set_rf_loss(value);
  // @@protoc_insertion_point(field_set:LossResult.rf_loss)
}

// required float lb_loss = 3;
inline bool LossResult::_internal_has_lb_loss() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool LossResult::has_lb_loss() const {
  return _internal_has_lb_loss();
}
inline void LossResult::clear_lb_loss() {
  lb_loss_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline float LossResult::_internal_lb_loss() const {
  return lb_loss_;
}
inline float LossResult::lb_loss() const {
  // @@protoc_insertion_point(field_get:LossResult.lb_loss)
  return _internal_lb_loss();
}
inline void LossResult::_internal_set_lb_loss(float value) {
  _has_bits_[0] |= 0x00000004u;
  lb_loss_ = value;
}
inline void LossResult::set_lb_loss(float value) {
  _internal_set_lb_loss(value);
  // @@protoc_insertion_point(field_set:LossResult.lb_loss)
}

// required float rb_loss = 4;
inline bool LossResult::_internal_has_rb_loss() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool LossResult::has_rb_loss() const {
  return _internal_has_rb_loss();
}
inline void LossResult::clear_rb_loss() {
  rb_loss_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline float LossResult::_internal_rb_loss() const {
  return rb_loss_;
}
inline float LossResult::rb_loss() const {
  // @@protoc_insertion_point(field_get:LossResult.rb_loss)
  return _internal_rb_loss();
}
inline void LossResult::_internal_set_rb_loss(float value) {
  _has_bits_[0] |= 0x00000008u;
  rb_loss_ = value;
}
inline void LossResult::set_rb_loss(float value) {
  _internal_set_rb_loss(value);
  // @@protoc_insertion_point(field_set:LossResult.rb_loss)
}

// required float total_avg_loss = 5;
inline bool LossResult::_internal_has_total_avg_loss() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool LossResult::has_total_avg_loss() const {
  return _internal_has_total_avg_loss();
}
inline void LossResult::clear_total_avg_loss() {
  total_avg_loss_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline float LossResult::_internal_total_avg_loss() const {
  return total_avg_loss_;
}
inline float LossResult::total_avg_loss() const {
  // @@protoc_insertion_point(field_get:LossResult.total_avg_loss)
  return _internal_total_avg_loss();
}
inline void LossResult::_internal_set_total_avg_loss(float value) {
  _has_bits_[0] |= 0x00000010u;
  total_avg_loss_ = value;
}
inline void LossResult::set_total_avg_loss(float value) {
  _internal_set_total_avg_loss(value);
  // @@protoc_insertion_point(field_set:LossResult.total_avg_loss)
}

// -------------------------------------------------------------------

// DetectResult

// required float cx = 1;
inline bool DetectResult::_internal_has_cx() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool DetectResult::has_cx() const {
  return _internal_has_cx();
}
inline void DetectResult::clear_cx() {
  cx_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline float DetectResult::_internal_cx() const {
  return cx_;
}
inline float DetectResult::cx() const {
  // @@protoc_insertion_point(field_get:DetectResult.cx)
  return _internal_cx();
}
inline void DetectResult::_internal_set_cx(float value) {
  _has_bits_[0] |= 0x00000002u;
  cx_ = value;
}
inline void DetectResult::set_cx(float value) {
  _internal_set_cx(value);
  // @@protoc_insertion_point(field_set:DetectResult.cx)
}

// required float cy = 2;
inline bool DetectResult::_internal_has_cy() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool DetectResult::has_cy() const {
  return _internal_has_cy();
}
inline void DetectResult::clear_cy() {
  cy_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline float DetectResult::_internal_cy() const {
  return cy_;
}
inline float DetectResult::cy() const {
  // @@protoc_insertion_point(field_get:DetectResult.cy)
  return _internal_cy();
}
inline void DetectResult::_internal_set_cy(float value) {
  _has_bits_[0] |= 0x00000004u;
  cy_ = value;
}
inline void DetectResult::set_cy(float value) {
  _internal_set_cy(value);
  // @@protoc_insertion_point(field_set:DetectResult.cy)
}

// required float theta = 3;
inline bool DetectResult::_internal_has_theta() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool DetectResult::has_theta() const {
  return _internal_has_theta();
}
inline void DetectResult::clear_theta() {
  theta_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline float DetectResult::_internal_theta() const {
  return theta_;
}
inline float DetectResult::theta() const {
  // @@protoc_insertion_point(field_get:DetectResult.theta)
  return _internal_theta();
}
inline void DetectResult::_internal_set_theta(float value) {
  _has_bits_[0] |= 0x00000008u;
  theta_ = value;
}
inline void DetectResult::set_theta(float value) {
  _internal_set_theta(value);
  // @@protoc_insertion_point(field_set:DetectResult.theta)
}

// required float wheel_base = 4;
inline bool DetectResult::_internal_has_wheel_base() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool DetectResult::has_wheel_base() const {
  return _internal_has_wheel_base();
}
inline void DetectResult::clear_wheel_base() {
  wheel_base_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline float DetectResult::_internal_wheel_base() const {
  return wheel_base_;
}
inline float DetectResult::wheel_base() const {
  // @@protoc_insertion_point(field_get:DetectResult.wheel_base)
  return _internal_wheel_base();
}
inline void DetectResult::_internal_set_wheel_base(float value) {
  _has_bits_[0] |= 0x00000010u;
  wheel_base_ = value;
}
inline void DetectResult::set_wheel_base(float value) {
  _internal_set_wheel_base(value);
  // @@protoc_insertion_point(field_set:DetectResult.wheel_base)
}

// required float width = 5;
inline bool DetectResult::_internal_has_width() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool DetectResult::has_width() const {
  return _internal_has_width();
}
inline void DetectResult::clear_width() {
  width_ = 0;
  _has_bits_[0] &= ~0x00000020u;
}
inline float DetectResult::_internal_width() const {
  return width_;
}
inline float DetectResult::width() const {
  // @@protoc_insertion_point(field_get:DetectResult.width)
  return _internal_width();
}
inline void DetectResult::_internal_set_width(float value) {
  _has_bits_[0] |= 0x00000020u;
  width_ = value;
}
inline void DetectResult::set_width(float value) {
  _internal_set_width(value);
  // @@protoc_insertion_point(field_set:DetectResult.width)
}

// required float body_width = 6;
inline bool DetectResult::_internal_has_body_width() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool DetectResult::has_body_width() const {
  return _internal_has_body_width();
}
inline void DetectResult::clear_body_width() {
  body_width_ = 0;
  _has_bits_[0] &= ~0x00000040u;
}
inline float DetectResult::_internal_body_width() const {
  return body_width_;
}
inline float DetectResult::body_width() const {
  // @@protoc_insertion_point(field_get:DetectResult.body_width)
  return _internal_body_width();
}
inline void DetectResult::_internal_set_body_width(float value) {
  _has_bits_[0] |= 0x00000040u;
  body_width_ = value;
}
inline void DetectResult::set_body_width(float value) {
  _internal_set_body_width(value);
  // @@protoc_insertion_point(field_set:DetectResult.body_width)
}

// required float front_theta = 7;
inline bool DetectResult::_internal_has_front_theta() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool DetectResult::has_front_theta() const {
  return _internal_has_front_theta();
}
inline void DetectResult::clear_front_theta() {
  front_theta_ = 0;
  _has_bits_[0] &= ~0x00000080u;
}
inline float DetectResult::_internal_front_theta() const {
  return front_theta_;
}
inline float DetectResult::front_theta() const {
  // @@protoc_insertion_point(field_get:DetectResult.front_theta)
  return _internal_front_theta();
}
inline void DetectResult::_internal_set_front_theta(float value) {
  _has_bits_[0] |= 0x00000080u;
  front_theta_ = value;
}
inline void DetectResult::set_front_theta(float value) {
  _internal_set_front_theta(value);
  // @@protoc_insertion_point(field_set:DetectResult.front_theta)
}

// required float single_wheel_width = 8;
inline bool DetectResult::_internal_has_single_wheel_width() const {
  bool value = (_has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool DetectResult::has_single_wheel_width() const {
  return _internal_has_single_wheel_width();
}
inline void DetectResult::clear_single_wheel_width() {
  single_wheel_width_ = 0;
  _has_bits_[0] &= ~0x00000100u;
}
inline float DetectResult::_internal_single_wheel_width() const {
  return single_wheel_width_;
}
inline float DetectResult::single_wheel_width() const {
  // @@protoc_insertion_point(field_get:DetectResult.single_wheel_width)
  return _internal_single_wheel_width();
}
inline void DetectResult::_internal_set_single_wheel_width(float value) {
  _has_bits_[0] |= 0x00000100u;
  single_wheel_width_ = value;
}
inline void DetectResult::set_single_wheel_width(float value) {
  _internal_set_single_wheel_width(value);
  // @@protoc_insertion_point(field_set:DetectResult.single_wheel_width)
}

// required float single_wheel_length = 9;
inline bool DetectResult::_internal_has_single_wheel_length() const {
  bool value = (_has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool DetectResult::has_single_wheel_length() const {
  return _internal_has_single_wheel_length();
}
inline void DetectResult::clear_single_wheel_length() {
  single_wheel_length_ = 0;
  _has_bits_[0] &= ~0x00000200u;
}
inline float DetectResult::_internal_single_wheel_length() const {
  return single_wheel_length_;
}
inline float DetectResult::single_wheel_length() const {
  // @@protoc_insertion_point(field_get:DetectResult.single_wheel_length)
  return _internal_single_wheel_length();
}
inline void DetectResult::_internal_set_single_wheel_length(float value) {
  _has_bits_[0] |= 0x00000200u;
  single_wheel_length_ = value;
}
inline void DetectResult::set_single_wheel_length(float value) {
  _internal_set_single_wheel_length(value);
  // @@protoc_insertion_point(field_set:DetectResult.single_wheel_length)
}

// required bool success = 10;
inline bool DetectResult::_internal_has_success() const {
  bool value = (_has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool DetectResult::has_success() const {
  return _internal_has_success();
}
inline void DetectResult::clear_success() {
  success_ = false;
  _has_bits_[0] &= ~0x00000400u;
}
inline bool DetectResult::_internal_success() const {
  return success_;
}
inline bool DetectResult::success() const {
  // @@protoc_insertion_point(field_get:DetectResult.success)
  return _internal_success();
}
inline void DetectResult::_internal_set_success(bool value) {
  _has_bits_[0] |= 0x00000400u;
  success_ = value;
}
inline void DetectResult::set_success(bool value) {
  _internal_set_success(value);
  // @@protoc_insertion_point(field_set:DetectResult.success)
}

// required .LossResult loss = 11;
inline bool DetectResult::_internal_has_loss() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || loss_ != nullptr);
  return value;
}
inline bool DetectResult::has_loss() const {
  return _internal_has_loss();
}
inline void DetectResult::clear_loss() {
  if (loss_ != nullptr) loss_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::LossResult& DetectResult::_internal_loss() const {
  const ::LossResult* p = loss_;
  return p != nullptr ? *p : *reinterpret_cast<const ::LossResult*>(
      &::_LossResult_default_instance_);
}
inline const ::LossResult& DetectResult::loss() const {
  // @@protoc_insertion_point(field_get:DetectResult.loss)
  return _internal_loss();
}
inline void DetectResult::unsafe_arena_set_allocated_loss(
    ::LossResult* loss) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(loss_);
  }
  loss_ = loss;
  if (loss) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:DetectResult.loss)
}
inline ::LossResult* DetectResult::release_loss() {
  _has_bits_[0] &= ~0x00000001u;
  ::LossResult* temp = loss_;
  loss_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::LossResult* DetectResult::unsafe_arena_release_loss() {
  // @@protoc_insertion_point(field_release:DetectResult.loss)
  _has_bits_[0] &= ~0x00000001u;
  ::LossResult* temp = loss_;
  loss_ = nullptr;
  return temp;
}
inline ::LossResult* DetectResult::_internal_mutable_loss() {
  _has_bits_[0] |= 0x00000001u;
  if (loss_ == nullptr) {
    auto* p = CreateMaybeMessage<::LossResult>(GetArena());
    loss_ = p;
  }
  return loss_;
}
inline ::LossResult* DetectResult::mutable_loss() {
  // @@protoc_insertion_point(field_mutable:DetectResult.loss)
  return _internal_mutable_loss();
}
inline void DetectResult::set_allocated_loss(::LossResult* loss) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete loss_;
  }
  if (loss) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(loss);
    if (message_arena != submessage_arena) {
      loss = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, loss, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  loss_ = loss;
  // @@protoc_insertion_point(field_set_allocated:DetectResult.loss)
}

// -------------------------------------------------------------------

// RegionEtc

// required double maxx = 1;
inline bool RegionEtc::_internal_has_maxx() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool RegionEtc::has_maxx() const {
  return _internal_has_maxx();
}
inline void RegionEtc::clear_maxx() {
  maxx_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline double RegionEtc::_internal_maxx() const {
  return maxx_;
}
inline double RegionEtc::maxx() const {
  // @@protoc_insertion_point(field_get:RegionEtc.maxx)
  return _internal_maxx();
}
inline void RegionEtc::_internal_set_maxx(double value) {
  _has_bits_[0] |= 0x00000001u;
  maxx_ = value;
}
inline void RegionEtc::set_maxx(double value) {
  _internal_set_maxx(value);
  // @@protoc_insertion_point(field_set:RegionEtc.maxx)
}

// required double minx = 2;
inline bool RegionEtc::_internal_has_minx() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool RegionEtc::has_minx() const {
  return _internal_has_minx();
}
inline void RegionEtc::clear_minx() {
  minx_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline double RegionEtc::_internal_minx() const {
  return minx_;
}
inline double RegionEtc::minx() const {
  // @@protoc_insertion_point(field_get:RegionEtc.minx)
  return _internal_minx();
}
inline void RegionEtc::_internal_set_minx(double value) {
  _has_bits_[0] |= 0x00000002u;
  minx_ = value;
}
inline void RegionEtc::set_minx(double value) {
  _internal_set_minx(value);
  // @@protoc_insertion_point(field_set:RegionEtc.minx)
}

// required double maxy = 3;
inline bool RegionEtc::_internal_has_maxy() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool RegionEtc::has_maxy() const {
  return _internal_has_maxy();
}
inline void RegionEtc::clear_maxy() {
  maxy_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline double RegionEtc::_internal_maxy() const {
  return maxy_;
}
inline double RegionEtc::maxy() const {
  // @@protoc_insertion_point(field_get:RegionEtc.maxy)
  return _internal_maxy();
}
inline void RegionEtc::_internal_set_maxy(double value) {
  _has_bits_[0] |= 0x00000004u;
  maxy_ = value;
}
inline void RegionEtc::set_maxy(double value) {
  _internal_set_maxy(value);
  // @@protoc_insertion_point(field_set:RegionEtc.maxy)
}

// required double miny = 4;
inline bool RegionEtc::_internal_has_miny() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool RegionEtc::has_miny() const {
  return _internal_has_miny();
}
inline void RegionEtc::clear_miny() {
  miny_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline double RegionEtc::_internal_miny() const {
  return miny_;
}
inline double RegionEtc::miny() const {
  // @@protoc_insertion_point(field_get:RegionEtc.miny)
  return _internal_miny();
}
inline void RegionEtc::_internal_set_miny(double value) {
  _has_bits_[0] |= 0x00000008u;
  miny_ = value;
}
inline void RegionEtc::set_miny(double value) {
  _internal_set_miny(value);
  // @@protoc_insertion_point(field_set:RegionEtc.miny)
}

// required double maxz = 5;
inline bool RegionEtc::_internal_has_maxz() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool RegionEtc::has_maxz() const {
  return _internal_has_maxz();
}
inline void RegionEtc::clear_maxz() {
  maxz_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline double RegionEtc::_internal_maxz() const {
  return maxz_;
}
inline double RegionEtc::maxz() const {
  // @@protoc_insertion_point(field_get:RegionEtc.maxz)
  return _internal_maxz();
}
inline void RegionEtc::_internal_set_maxz(double value) {
  _has_bits_[0] |= 0x00000010u;
  maxz_ = value;
}
inline void RegionEtc::set_maxz(double value) {
  _internal_set_maxz(value);
  // @@protoc_insertion_point(field_set:RegionEtc.maxz)
}

// required double minz = 6;
inline bool RegionEtc::_internal_has_minz() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool RegionEtc::has_minz() const {
  return _internal_has_minz();
}
inline void RegionEtc::clear_minz() {
  minz_ = 0;
  _has_bits_[0] &= ~0x00000020u;
}
inline double RegionEtc::_internal_minz() const {
  return minz_;
}
inline double RegionEtc::minz() const {
  // @@protoc_insertion_point(field_get:RegionEtc.minz)
  return _internal_minz();
}
inline void RegionEtc::_internal_set_minz(double value) {
  _has_bits_[0] |= 0x00000020u;
  minz_ = value;
}
inline void RegionEtc::set_minz(double value) {
  _internal_set_minz(value);
  // @@protoc_insertion_point(field_set:RegionEtc.minz)
}

// -------------------------------------------------------------------

// Region

// required .RegionEtc cut_region = 1;
inline bool Region::_internal_has_cut_region() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || cut_region_ != nullptr);
  return value;
}
inline bool Region::has_cut_region() const {
  return _internal_has_cut_region();
}
inline void Region::clear_cut_region() {
  if (cut_region_ != nullptr) cut_region_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::RegionEtc& Region::_internal_cut_region() const {
  const ::RegionEtc* p = cut_region_;
  return p != nullptr ? *p : *reinterpret_cast<const ::RegionEtc*>(
      &::_RegionEtc_default_instance_);
}
inline const ::RegionEtc& Region::cut_region() const {
  // @@protoc_insertion_point(field_get:Region.cut_region)
  return _internal_cut_region();
}
inline void Region::unsafe_arena_set_allocated_cut_region(
    ::RegionEtc* cut_region) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(cut_region_);
  }
  cut_region_ = cut_region;
  if (cut_region) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Region.cut_region)
}
inline ::RegionEtc* Region::release_cut_region() {
  _has_bits_[0] &= ~0x00000001u;
  ::RegionEtc* temp = cut_region_;
  cut_region_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::RegionEtc* Region::unsafe_arena_release_cut_region() {
  // @@protoc_insertion_point(field_release:Region.cut_region)
  _has_bits_[0] &= ~0x00000001u;
  ::RegionEtc* temp = cut_region_;
  cut_region_ = nullptr;
  return temp;
}
inline ::RegionEtc* Region::_internal_mutable_cut_region() {
  _has_bits_[0] |= 0x00000001u;
  if (cut_region_ == nullptr) {
    auto* p = CreateMaybeMessage<::RegionEtc>(GetArena());
    cut_region_ = p;
  }
  return cut_region_;
}
inline ::RegionEtc* Region::mutable_cut_region() {
  // @@protoc_insertion_point(field_mutable:Region.cut_region)
  return _internal_mutable_cut_region();
}
inline void Region::set_allocated_cut_region(::RegionEtc* cut_region) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete cut_region_;
  }
  if (cut_region) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(cut_region);
    if (message_arena != submessage_arena) {
      cut_region = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cut_region, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  cut_region_ = cut_region;
  // @@protoc_insertion_point(field_set_allocated:Region.cut_region)
}

// required float turnplate_cx = 2;
inline bool Region::_internal_has_turnplate_cx() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Region::has_turnplate_cx() const {
  return _internal_has_turnplate_cx();
}
inline void Region::clear_turnplate_cx() {
  turnplate_cx_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline float Region::_internal_turnplate_cx() const {
  return turnplate_cx_;
}
inline float Region::turnplate_cx() const {
  // @@protoc_insertion_point(field_get:Region.turnplate_cx)
  return _internal_turnplate_cx();
}
inline void Region::_internal_set_turnplate_cx(float value) {
  _has_bits_[0] |= 0x00000002u;
  turnplate_cx_ = value;
}
inline void Region::set_turnplate_cx(float value) {
  _internal_set_turnplate_cx(value);
  // @@protoc_insertion_point(field_set:Region.turnplate_cx)
}

// required float turnplate_cy = 3;
inline bool Region::_internal_has_turnplate_cy() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Region::has_turnplate_cy() const {
  return _internal_has_turnplate_cy();
}
inline void Region::clear_turnplate_cy() {
  turnplate_cy_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline float Region::_internal_turnplate_cy() const {
  return turnplate_cy_;
}
inline float Region::turnplate_cy() const {
  // @@protoc_insertion_point(field_get:Region.turnplate_cy)
  return _internal_turnplate_cy();
}
inline void Region::_internal_set_turnplate_cy(float value) {
  _has_bits_[0] |= 0x00000004u;
  turnplate_cy_ = value;
}
inline void Region::set_turnplate_cy(float value) {
  _internal_set_turnplate_cy(value);
  // @@protoc_insertion_point(field_set:Region.turnplate_cy)
}

// required float border_minx = 4;
inline bool Region::_internal_has_border_minx() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Region::has_border_minx() const {
  return _internal_has_border_minx();
}
inline void Region::clear_border_minx() {
  border_minx_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline float Region::_internal_border_minx() const {
  return border_minx_;
}
inline float Region::border_minx() const {
  // @@protoc_insertion_point(field_get:Region.border_minx)
  return _internal_border_minx();
}
inline void Region::_internal_set_border_minx(float value) {
  _has_bits_[0] |= 0x00000008u;
  border_minx_ = value;
}
inline void Region::set_border_minx(float value) {
  _internal_set_border_minx(value);
  // @@protoc_insertion_point(field_set:Region.border_minx)
}

// required float border_maxx = 5;
inline bool Region::_internal_has_border_maxx() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Region::has_border_maxx() const {
  return _internal_has_border_maxx();
}
inline void Region::clear_border_maxx() {
  border_maxx_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline float Region::_internal_border_maxx() const {
  return border_maxx_;
}
inline float Region::border_maxx() const {
  // @@protoc_insertion_point(field_get:Region.border_maxx)
  return _internal_border_maxx();
}
inline void Region::_internal_set_border_maxx(float value) {
  _has_bits_[0] |= 0x00000010u;
  border_maxx_ = value;
}
inline void Region::set_border_maxx(float value) {
  _internal_set_border_maxx(value);
  // @@protoc_insertion_point(field_set:Region.border_maxx)
}

// required float plc_offsetx = 6;
inline bool Region::_internal_has_plc_offsetx() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Region::has_plc_offsetx() const {
  return _internal_has_plc_offsetx();
}
inline void Region::clear_plc_offsetx() {
  plc_offsetx_ = 0;
  _has_bits_[0] &= ~0x00000020u;
}
inline float Region::_internal_plc_offsetx() const {
  return plc_offsetx_;
}
inline float Region::plc_offsetx() const {
  // @@protoc_insertion_point(field_get:Region.plc_offsetx)
  return _internal_plc_offsetx();
}
inline void Region::_internal_set_plc_offsetx(float value) {
  _has_bits_[0] |= 0x00000020u;
  plc_offsetx_ = value;
}
inline void Region::set_plc_offsetx(float value) {
  _internal_set_plc_offsetx(value);
  // @@protoc_insertion_point(field_set:Region.plc_offsetx)
}

// required float plc_offsety = 7;
inline bool Region::_internal_has_plc_offsety() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Region::has_plc_offsety() const {
  return _internal_has_plc_offsety();
}
inline void Region::clear_plc_offsety() {
  plc_offsety_ = 0;
  _has_bits_[0] &= ~0x00000040u;
}
inline float Region::_internal_plc_offsety() const {
  return plc_offsety_;
}
inline float Region::plc_offsety() const {
  // @@protoc_insertion_point(field_get:Region.plc_offsety)
  return _internal_plc_offsety();
}
inline void Region::_internal_set_plc_offsety(float value) {
  _has_bits_[0] |= 0x00000040u;
  plc_offsety_ = value;
}
inline void Region::set_plc_offsety(float value) {
  _internal_set_plc_offsety(value);
  // @@protoc_insertion_point(field_set:Region.plc_offsety)
}

// required float plc_offset_degree = 8;
inline bool Region::_internal_has_plc_offset_degree() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Region::has_plc_offset_degree() const {
  return _internal_has_plc_offset_degree();
}
inline void Region::clear_plc_offset_degree() {
  plc_offset_degree_ = 0;
  _has_bits_[0] &= ~0x00000080u;
}
inline float Region::_internal_plc_offset_degree() const {
  return plc_offset_degree_;
}
inline float Region::plc_offset_degree() const {
  // @@protoc_insertion_point(field_get:Region.plc_offset_degree)
  return _internal_plc_offset_degree();
}
inline void Region::_internal_set_plc_offset_degree(float value) {
  _has_bits_[0] |= 0x00000080u;
  plc_offset_degree_ = value;
}
inline void Region::set_plc_offset_degree(float value) {
  _internal_set_plc_offset_degree(value);
  // @@protoc_insertion_point(field_set:Region.plc_offset_degree)
}

// required float plc_border_miny = 9;
inline bool Region::_internal_has_plc_border_miny() const {
  bool value = (_has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool Region::has_plc_border_miny() const {
  return _internal_has_plc_border_miny();
}
inline void Region::clear_plc_border_miny() {
  plc_border_miny_ = 0;
  _has_bits_[0] &= ~0x00000100u;
}
inline float Region::_internal_plc_border_miny() const {
  return plc_border_miny_;
}
inline float Region::plc_border_miny() const {
  // @@protoc_insertion_point(field_get:Region.plc_border_miny)
  return _internal_plc_border_miny();
}
inline void Region::_internal_set_plc_border_miny(float value) {
  _has_bits_[0] |= 0x00000100u;
  plc_border_miny_ = value;
}
inline void Region::set_plc_border_miny(float value) {
  _internal_set_plc_border_miny(value);
  // @@protoc_insertion_point(field_set:Region.plc_border_miny)
}

// required float plc_border_maxy = 10;
inline bool Region::_internal_has_plc_border_maxy() const {
  bool value = (_has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool Region::has_plc_border_maxy() const {
  return _internal_has_plc_border_maxy();
}
inline void Region::clear_plc_border_maxy() {
  plc_border_maxy_ = 0;
  _has_bits_[0] &= ~0x00000200u;
}
inline float Region::_internal_plc_border_maxy() const {
  return plc_border_maxy_;
}
inline float Region::plc_border_maxy() const {
  // @@protoc_insertion_point(field_get:Region.plc_border_maxy)
  return _internal_plc_border_maxy();
}
inline void Region::_internal_set_plc_border_maxy(float value) {
  _has_bits_[0] |= 0x00000200u;
  plc_border_maxy_ = value;
}
inline void Region::set_plc_border_maxy(float value) {
  _internal_set_plc_border_maxy(value);
  // @@protoc_insertion_point(field_set:Region.plc_border_maxy)
}

// required float car_min_width = 11;
inline bool Region::_internal_has_car_min_width() const {
  bool value = (_has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool Region::has_car_min_width() const {
  return _internal_has_car_min_width();
}
inline void Region::clear_car_min_width() {
  car_min_width_ = 0;
  _has_bits_[0] &= ~0x00000400u;
}
inline float Region::_internal_car_min_width() const {
  return car_min_width_;
}
inline float Region::car_min_width() const {
  // @@protoc_insertion_point(field_get:Region.car_min_width)
  return _internal_car_min_width();
}
inline void Region::_internal_set_car_min_width(float value) {
  _has_bits_[0] |= 0x00000400u;
  car_min_width_ = value;
}
inline void Region::set_car_min_width(float value) {
  _internal_set_car_min_width(value);
  // @@protoc_insertion_point(field_set:Region.car_min_width)
}

// required float car_max_width = 12;
inline bool Region::_internal_has_car_max_width() const {
  bool value = (_has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool Region::has_car_max_width() const {
  return _internal_has_car_max_width();
}
inline void Region::clear_car_max_width() {
  car_max_width_ = 0;
  _has_bits_[0] &= ~0x00000800u;
}
inline float Region::_internal_car_max_width() const {
  return car_max_width_;
}
inline float Region::car_max_width() const {
  // @@protoc_insertion_point(field_get:Region.car_max_width)
  return _internal_car_max_width();
}
inline void Region::_internal_set_car_max_width(float value) {
  _has_bits_[0] |= 0x00000800u;
  car_max_width_ = value;
}
inline void Region::set_car_max_width(float value) {
  _internal_set_car_max_width(value);
  // @@protoc_insertion_point(field_set:Region.car_max_width)
}

// required float car_min_wheelbase = 13;
inline bool Region::_internal_has_car_min_wheelbase() const {
  bool value = (_has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool Region::has_car_min_wheelbase() const {
  return _internal_has_car_min_wheelbase();
}
inline void Region::clear_car_min_wheelbase() {
  car_min_wheelbase_ = 0;
  _has_bits_[0] &= ~0x00001000u;
}
inline float Region::_internal_car_min_wheelbase() const {
  return car_min_wheelbase_;
}
inline float Region::car_min_wheelbase() const {
  // @@protoc_insertion_point(field_get:Region.car_min_wheelbase)
  return _internal_car_min_wheelbase();
}
inline void Region::_internal_set_car_min_wheelbase(float value) {
  _has_bits_[0] |= 0x00001000u;
  car_min_wheelbase_ = value;
}
inline void Region::set_car_min_wheelbase(float value) {
  _internal_set_car_min_wheelbase(value);
  // @@protoc_insertion_point(field_set:Region.car_min_wheelbase)
}

// required float car_max_wheelbase = 14;
inline bool Region::_internal_has_car_max_wheelbase() const {
  bool value = (_has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool Region::has_car_max_wheelbase() const {
  return _internal_has_car_max_wheelbase();
}
inline void Region::clear_car_max_wheelbase() {
  car_max_wheelbase_ = 0;
  _has_bits_[0] &= ~0x00002000u;
}
inline float Region::_internal_car_max_wheelbase() const {
  return car_max_wheelbase_;
}
inline float Region::car_max_wheelbase() const {
  // @@protoc_insertion_point(field_get:Region.car_max_wheelbase)
  return _internal_car_max_wheelbase();
}
inline void Region::_internal_set_car_max_wheelbase(float value) {
  _has_bits_[0] |= 0x00002000u;
  car_max_wheelbase_ = value;
}
inline void Region::set_car_max_wheelbase(float value) {
  _internal_set_car_max_wheelbase(value);
  // @@protoc_insertion_point(field_set:Region.car_max_wheelbase)
}

// required float turnplate_angle_min = 15;
inline bool Region::_internal_has_turnplate_angle_min() const {
  bool value = (_has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool Region::has_turnplate_angle_min() const {
  return _internal_has_turnplate_angle_min();
}
inline void Region::clear_turnplate_angle_min() {
  turnplate_angle_min_ = 0;
  _has_bits_[0] &= ~0x00004000u;
}
inline float Region::_internal_turnplate_angle_min() const {
  return turnplate_angle_min_;
}
inline float Region::turnplate_angle_min() const {
  // @@protoc_insertion_point(field_get:Region.turnplate_angle_min)
  return _internal_turnplate_angle_min();
}
inline void Region::_internal_set_turnplate_angle_min(float value) {
  _has_bits_[0] |= 0x00004000u;
  turnplate_angle_min_ = value;
}
inline void Region::set_turnplate_angle_min(float value) {
  _internal_set_turnplate_angle_min(value);
  // @@protoc_insertion_point(field_set:Region.turnplate_angle_min)
}

// required float turnplate_angle_max = 16;
inline bool Region::_internal_has_turnplate_angle_max() const {
  bool value = (_has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool Region::has_turnplate_angle_max() const {
  return _internal_has_turnplate_angle_max();
}
inline void Region::clear_turnplate_angle_max() {
  turnplate_angle_max_ = 0;
  _has_bits_[0] &= ~0x00008000u;
}
inline float Region::_internal_turnplate_angle_max() const {
  return turnplate_angle_max_;
}
inline float Region::turnplate_angle_max() const {
  // @@protoc_insertion_point(field_get:Region.turnplate_angle_max)
  return _internal_turnplate_angle_max();
}
inline void Region::_internal_set_turnplate_angle_max(float value) {
  _has_bits_[0] |= 0x00008000u;
  turnplate_angle_max_ = value;
}
inline void Region::set_turnplate_angle_max(float value) {
  _internal_set_turnplate_angle_max(value);
  // @@protoc_insertion_point(field_set:Region.turnplate_angle_max)
}

// required float turnplate_angle_limit_anti_clockwise = 17;
inline bool Region::_internal_has_turnplate_angle_limit_anti_clockwise() const {
  bool value = (_has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool Region::has_turnplate_angle_limit_anti_clockwise() const {
  return _internal_has_turnplate_angle_limit_anti_clockwise();
}
inline void Region::clear_turnplate_angle_limit_anti_clockwise() {
  turnplate_angle_limit_anti_clockwise_ = 0;
  _has_bits_[0] &= ~0x00010000u;
}
inline float Region::_internal_turnplate_angle_limit_anti_clockwise() const {
  return turnplate_angle_limit_anti_clockwise_;
}
inline float Region::turnplate_angle_limit_anti_clockwise() const {
  // @@protoc_insertion_point(field_get:Region.turnplate_angle_limit_anti_clockwise)
  return _internal_turnplate_angle_limit_anti_clockwise();
}
inline void Region::_internal_set_turnplate_angle_limit_anti_clockwise(float value) {
  _has_bits_[0] |= 0x00010000u;
  turnplate_angle_limit_anti_clockwise_ = value;
}
inline void Region::set_turnplate_angle_limit_anti_clockwise(float value) {
  _internal_set_turnplate_angle_limit_anti_clockwise(value);
  // @@protoc_insertion_point(field_set:Region.turnplate_angle_limit_anti_clockwise)
}

// required float turnplate_angle_limit_clockwise = 18;
inline bool Region::_internal_has_turnplate_angle_limit_clockwise() const {
  bool value = (_has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool Region::has_turnplate_angle_limit_clockwise() const {
  return _internal_has_turnplate_angle_limit_clockwise();
}
inline void Region::clear_turnplate_angle_limit_clockwise() {
  turnplate_angle_limit_clockwise_ = 0;
  _has_bits_[0] &= ~0x00020000u;
}
inline float Region::_internal_turnplate_angle_limit_clockwise() const {
  return turnplate_angle_limit_clockwise_;
}
inline float Region::turnplate_angle_limit_clockwise() const {
  // @@protoc_insertion_point(field_get:Region.turnplate_angle_limit_clockwise)
  return _internal_turnplate_angle_limit_clockwise();
}
inline void Region::_internal_set_turnplate_angle_limit_clockwise(float value) {
  _has_bits_[0] |= 0x00020000u;
  turnplate_angle_limit_clockwise_ = value;
}
inline void Region::set_turnplate_angle_limit_clockwise(float value) {
  _internal_set_turnplate_angle_limit_clockwise(value);
  // @@protoc_insertion_point(field_set:Region.turnplate_angle_limit_clockwise)
}

// -------------------------------------------------------------------

// MeasureLidar

// required string measureTopic = 1;
inline bool MeasureLidar::_internal_has_measuretopic() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MeasureLidar::has_measuretopic() const {
  return _internal_has_measuretopic();
}
inline void MeasureLidar::clear_measuretopic() {
  measuretopic_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MeasureLidar::measuretopic() const {
  // @@protoc_insertion_point(field_get:MeasureLidar.measureTopic)
  return _internal_measuretopic();
}
inline void MeasureLidar::set_measuretopic(const std::string& value) {
  _internal_set_measuretopic(value);
  // @@protoc_insertion_point(field_set:MeasureLidar.measureTopic)
}
inline std::string* MeasureLidar::mutable_measuretopic() {
  // @@protoc_insertion_point(field_mutable:MeasureLidar.measureTopic)
  return _internal_mutable_measuretopic();
}
inline const std::string& MeasureLidar::_internal_measuretopic() const {
  return measuretopic_.Get();
}
inline void MeasureLidar::_internal_set_measuretopic(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  measuretopic_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void MeasureLidar::set_measuretopic(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  measuretopic_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:MeasureLidar.measureTopic)
}
inline void MeasureLidar::set_measuretopic(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  measuretopic_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:MeasureLidar.measureTopic)
}
inline void MeasureLidar::set_measuretopic(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  measuretopic_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:MeasureLidar.measureTopic)
}
inline std::string* MeasureLidar::_internal_mutable_measuretopic() {
  _has_bits_[0] |= 0x00000001u;
  return measuretopic_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* MeasureLidar::release_measuretopic() {
  // @@protoc_insertion_point(field_release:MeasureLidar.measureTopic)
  if (!_internal_has_measuretopic()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return measuretopic_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void MeasureLidar::set_allocated_measuretopic(std::string* measuretopic) {
  if (measuretopic != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  measuretopic_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), measuretopic,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:MeasureLidar.measureTopic)
}

// required .Region region = 2;
inline bool MeasureLidar::_internal_has_region() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || region_ != nullptr);
  return value;
}
inline bool MeasureLidar::has_region() const {
  return _internal_has_region();
}
inline void MeasureLidar::clear_region() {
  if (region_ != nullptr) region_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::Region& MeasureLidar::_internal_region() const {
  const ::Region* p = region_;
  return p != nullptr ? *p : *reinterpret_cast<const ::Region*>(
      &::_Region_default_instance_);
}
inline const ::Region& MeasureLidar::region() const {
  // @@protoc_insertion_point(field_get:MeasureLidar.region)
  return _internal_region();
}
inline void MeasureLidar::unsafe_arena_set_allocated_region(
    ::Region* region) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(region_);
  }
  region_ = region;
  if (region) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:MeasureLidar.region)
}
inline ::Region* MeasureLidar::release_region() {
  _has_bits_[0] &= ~0x00000002u;
  ::Region* temp = region_;
  region_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::Region* MeasureLidar::unsafe_arena_release_region() {
  // @@protoc_insertion_point(field_release:MeasureLidar.region)
  _has_bits_[0] &= ~0x00000002u;
  ::Region* temp = region_;
  region_ = nullptr;
  return temp;
}
inline ::Region* MeasureLidar::_internal_mutable_region() {
  _has_bits_[0] |= 0x00000002u;
  if (region_ == nullptr) {
    auto* p = CreateMaybeMessage<::Region>(GetArena());
    region_ = p;
  }
  return region_;
}
inline ::Region* MeasureLidar::mutable_region() {
  // @@protoc_insertion_point(field_mutable:MeasureLidar.region)
  return _internal_mutable_region();
}
inline void MeasureLidar::set_allocated_region(::Region* region) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete region_;
  }
  if (region) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(region);
    if (message_arena != submessage_arena) {
      region = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, region, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  region_ = region;
  // @@protoc_insertion_point(field_set_allocated:MeasureLidar.region)
}

// repeated string lidarTopic = 5;
inline int MeasureLidar::_internal_lidartopic_size() const {
  return lidartopic_.size();
}
inline int MeasureLidar::lidartopic_size() const {
  return _internal_lidartopic_size();
}
inline void MeasureLidar::clear_lidartopic() {
  lidartopic_.Clear();
}
inline std::string* MeasureLidar::add_lidartopic() {
  // @@protoc_insertion_point(field_add_mutable:MeasureLidar.lidarTopic)
  return _internal_add_lidartopic();
}
inline const std::string& MeasureLidar::_internal_lidartopic(int index) const {
  return lidartopic_.Get(index);
}
inline const std::string& MeasureLidar::lidartopic(int index) const {
  // @@protoc_insertion_point(field_get:MeasureLidar.lidarTopic)
  return _internal_lidartopic(index);
}
inline std::string* MeasureLidar::mutable_lidartopic(int index) {
  // @@protoc_insertion_point(field_mutable:MeasureLidar.lidarTopic)
  return lidartopic_.Mutable(index);
}
inline void MeasureLidar::set_lidartopic(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:MeasureLidar.lidarTopic)
  lidartopic_.Mutable(index)->assign(value);
}
inline void MeasureLidar::set_lidartopic(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:MeasureLidar.lidarTopic)
  lidartopic_.Mutable(index)->assign(std::move(value));
}
inline void MeasureLidar::set_lidartopic(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  lidartopic_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:MeasureLidar.lidarTopic)
}
inline void MeasureLidar::set_lidartopic(int index, const char* value, size_t size) {
  lidartopic_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:MeasureLidar.lidarTopic)
}
inline std::string* MeasureLidar::_internal_add_lidartopic() {
  return lidartopic_.Add();
}
inline void MeasureLidar::add_lidartopic(const std::string& value) {
  lidartopic_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:MeasureLidar.lidarTopic)
}
inline void MeasureLidar::add_lidartopic(std::string&& value) {
  lidartopic_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:MeasureLidar.lidarTopic)
}
inline void MeasureLidar::add_lidartopic(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  lidartopic_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:MeasureLidar.lidarTopic)
}
inline void MeasureLidar::add_lidartopic(const char* value, size_t size) {
  lidartopic_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:MeasureLidar.lidarTopic)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
MeasureLidar::lidartopic() const {
  // @@protoc_insertion_point(field_list:MeasureLidar.lidarTopic)
  return lidartopic_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
MeasureLidar::mutable_lidartopic() {
  // @@protoc_insertion_point(field_mutable_list:MeasureLidar.lidarTopic)
  return &lidartopic_;
}

// -------------------------------------------------------------------

// MeasureConfig

// required string sendTopics = 1;
inline bool MeasureConfig::_internal_has_sendtopics() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MeasureConfig::has_sendtopics() const {
  return _internal_has_sendtopics();
}
inline void MeasureConfig::clear_sendtopics() {
  sendtopics_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MeasureConfig::sendtopics() const {
  // @@protoc_insertion_point(field_get:MeasureConfig.sendTopics)
  return _internal_sendtopics();
}
inline void MeasureConfig::set_sendtopics(const std::string& value) {
  _internal_set_sendtopics(value);
  // @@protoc_insertion_point(field_set:MeasureConfig.sendTopics)
}
inline std::string* MeasureConfig::mutable_sendtopics() {
  // @@protoc_insertion_point(field_mutable:MeasureConfig.sendTopics)
  return _internal_mutable_sendtopics();
}
inline const std::string& MeasureConfig::_internal_sendtopics() const {
  return sendtopics_.Get();
}
inline void MeasureConfig::_internal_set_sendtopics(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  sendtopics_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void MeasureConfig::set_sendtopics(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  sendtopics_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:MeasureConfig.sendTopics)
}
inline void MeasureConfig::set_sendtopics(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  sendtopics_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:MeasureConfig.sendTopics)
}
inline void MeasureConfig::set_sendtopics(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  sendtopics_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:MeasureConfig.sendTopics)
}
inline std::string* MeasureConfig::_internal_mutable_sendtopics() {
  _has_bits_[0] |= 0x00000001u;
  return sendtopics_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* MeasureConfig::release_sendtopics() {
  // @@protoc_insertion_point(field_release:MeasureConfig.sendTopics)
  if (!_internal_has_sendtopics()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return sendtopics_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void MeasureConfig::set_allocated_sendtopics(std::string* sendtopics) {
  if (sendtopics != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  sendtopics_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sendtopics,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:MeasureConfig.sendTopics)
}

// required string lidarTopics = 2;
inline bool MeasureConfig::_internal_has_lidartopics() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool MeasureConfig::has_lidartopics() const {
  return _internal_has_lidartopics();
}
inline void MeasureConfig::clear_lidartopics() {
  lidartopics_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& MeasureConfig::lidartopics() const {
  // @@protoc_insertion_point(field_get:MeasureConfig.lidarTopics)
  return _internal_lidartopics();
}
inline void MeasureConfig::set_lidartopics(const std::string& value) {
  _internal_set_lidartopics(value);
  // @@protoc_insertion_point(field_set:MeasureConfig.lidarTopics)
}
inline std::string* MeasureConfig::mutable_lidartopics() {
  // @@protoc_insertion_point(field_mutable:MeasureConfig.lidarTopics)
  return _internal_mutable_lidartopics();
}
inline const std::string& MeasureConfig::_internal_lidartopics() const {
  return lidartopics_.Get();
}
inline void MeasureConfig::_internal_set_lidartopics(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  lidartopics_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void MeasureConfig::set_lidartopics(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  lidartopics_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:MeasureConfig.lidarTopics)
}
inline void MeasureConfig::set_lidartopics(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  lidartopics_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:MeasureConfig.lidarTopics)
}
inline void MeasureConfig::set_lidartopics(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000002u;
  lidartopics_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:MeasureConfig.lidarTopics)
}
inline std::string* MeasureConfig::_internal_mutable_lidartopics() {
  _has_bits_[0] |= 0x00000002u;
  return lidartopics_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* MeasureConfig::release_lidartopics() {
  // @@protoc_insertion_point(field_release:MeasureConfig.lidarTopics)
  if (!_internal_has_lidartopics()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return lidartopics_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void MeasureConfig::set_allocated_lidartopics(std::string* lidartopics) {
  if (lidartopics != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  lidartopics_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), lidartopics,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:MeasureConfig.lidarTopics)
}

// repeated .MeasureLidar measures = 5;
inline int MeasureConfig::_internal_measures_size() const {
  return measures_.size();
}
inline int MeasureConfig::measures_size() const {
  return _internal_measures_size();
}
inline void MeasureConfig::clear_measures() {
  measures_.Clear();
}
inline ::MeasureLidar* MeasureConfig::mutable_measures(int index) {
  // @@protoc_insertion_point(field_mutable:MeasureConfig.measures)
  return measures_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MeasureLidar >*
MeasureConfig::mutable_measures() {
  // @@protoc_insertion_point(field_mutable_list:MeasureConfig.measures)
  return &measures_;
}
inline const ::MeasureLidar& MeasureConfig::_internal_measures(int index) const {
  return measures_.Get(index);
}
inline const ::MeasureLidar& MeasureConfig::measures(int index) const {
  // @@protoc_insertion_point(field_get:MeasureConfig.measures)
  return _internal_measures(index);
}
inline ::MeasureLidar* MeasureConfig::_internal_add_measures() {
  return measures_.Add();
}
inline ::MeasureLidar* MeasureConfig::add_measures() {
  // @@protoc_insertion_point(field_add:MeasureConfig.measures)
  return _internal_add_measures();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::MeasureLidar >&
MeasureConfig::measures() const {
  // @@protoc_insertion_point(field_list:MeasureConfig.measures)
  return measures_;
}

// -------------------------------------------------------------------

// measure_info

// required float cx = 1 [default = 0];
inline bool measure_info::_internal_has_cx() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool measure_info::has_cx() const {
  return _internal_has_cx();
}
inline void measure_info::clear_cx() {
  cx_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline float measure_info::_internal_cx() const {
  return cx_;
}
inline float measure_info::cx() const {
  // @@protoc_insertion_point(field_get:measure_info.cx)
  return _internal_cx();
}
inline void measure_info::_internal_set_cx(float value) {
  _has_bits_[0] |= 0x00000001u;
  cx_ = value;
}
inline void measure_info::set_cx(float value) {
  _internal_set_cx(value);
  // @@protoc_insertion_point(field_set:measure_info.cx)
}

// required float cy = 2 [default = 0];
inline bool measure_info::_internal_has_cy() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool measure_info::has_cy() const {
  return _internal_has_cy();
}
inline void measure_info::clear_cy() {
  cy_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline float measure_info::_internal_cy() const {
  return cy_;
}
inline float measure_info::cy() const {
  // @@protoc_insertion_point(field_get:measure_info.cy)
  return _internal_cy();
}
inline void measure_info::_internal_set_cy(float value) {
  _has_bits_[0] |= 0x00000002u;
  cy_ = value;
}
inline void measure_info::set_cy(float value) {
  _internal_set_cy(value);
  // @@protoc_insertion_point(field_set:measure_info.cy)
}

// required float theta = 3 [default = 0];
inline bool measure_info::_internal_has_theta() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool measure_info::has_theta() const {
  return _internal_has_theta();
}
inline void measure_info::clear_theta() {
  theta_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline float measure_info::_internal_theta() const {
  return theta_;
}
inline float measure_info::theta() const {
  // @@protoc_insertion_point(field_get:measure_info.theta)
  return _internal_theta();
}
inline void measure_info::_internal_set_theta(float value) {
  _has_bits_[0] |= 0x00000004u;
  theta_ = value;
}
inline void measure_info::set_theta(float value) {
  _internal_set_theta(value);
  // @@protoc_insertion_point(field_set:measure_info.theta)
}

// required float length = 4 [default = 0];
inline bool measure_info::_internal_has_length() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool measure_info::has_length() const {
  return _internal_has_length();
}
inline void measure_info::clear_length() {
  length_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline float measure_info::_internal_length() const {
  return length_;
}
inline float measure_info::length() const {
  // @@protoc_insertion_point(field_get:measure_info.length)
  return _internal_length();
}
inline void measure_info::_internal_set_length(float value) {
  _has_bits_[0] |= 0x00000008u;
  length_ = value;
}
inline void measure_info::set_length(float value) {
  _internal_set_length(value);
  // @@protoc_insertion_point(field_set:measure_info.length)
}

// required float width = 5 [default = 0];
inline bool measure_info::_internal_has_width() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool measure_info::has_width() const {
  return _internal_has_width();
}
inline void measure_info::clear_width() {
  width_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline float measure_info::_internal_width() const {
  return width_;
}
inline float measure_info::width() const {
  // @@protoc_insertion_point(field_get:measure_info.width)
  return _internal_width();
}
inline void measure_info::_internal_set_width(float value) {
  _has_bits_[0] |= 0x00000010u;
  width_ = value;
}
inline void measure_info::set_width(float value) {
  _internal_set_width(value);
  // @@protoc_insertion_point(field_set:measure_info.width)
}

// required float height = 6 [default = 0];
inline bool measure_info::_internal_has_height() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool measure_info::has_height() const {
  return _internal_has_height();
}
inline void measure_info::clear_height() {
  height_ = 0;
  _has_bits_[0] &= ~0x00000020u;
}
inline float measure_info::_internal_height() const {
  return height_;
}
inline float measure_info::height() const {
  // @@protoc_insertion_point(field_get:measure_info.height)
  return _internal_height();
}
inline void measure_info::_internal_set_height(float value) {
  _has_bits_[0] |= 0x00000020u;
  height_ = value;
}
inline void measure_info::set_height(float value) {
  _internal_set_height(value);
  // @@protoc_insertion_point(field_set:measure_info.height)
}

// required float wheelbase = 7 [default = 0];
inline bool measure_info::_internal_has_wheelbase() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool measure_info::has_wheelbase() const {
  return _internal_has_wheelbase();
}
inline void measure_info::clear_wheelbase() {
  wheelbase_ = 0;
  _has_bits_[0] &= ~0x00000040u;
}
inline float measure_info::_internal_wheelbase() const {
  return wheelbase_;
}
inline float measure_info::wheelbase() const {
  // @@protoc_insertion_point(field_get:measure_info.wheelbase)
  return _internal_wheelbase();
}
inline void measure_info::_internal_set_wheelbase(float value) {
  _has_bits_[0] |= 0x00000040u;
  wheelbase_ = value;
}
inline void measure_info::set_wheelbase(float value) {
  _internal_set_wheelbase(value);
  // @@protoc_insertion_point(field_set:measure_info.wheelbase)
}

// required float front_theta = 8 [default = 0];
inline bool measure_info::_internal_has_front_theta() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool measure_info::has_front_theta() const {
  return _internal_has_front_theta();
}
inline void measure_info::clear_front_theta() {
  front_theta_ = 0;
  _has_bits_[0] &= ~0x00000080u;
}
inline float measure_info::_internal_front_theta() const {
  return front_theta_;
}
inline float measure_info::front_theta() const {
  // @@protoc_insertion_point(field_get:measure_info.front_theta)
  return _internal_front_theta();
}
inline void measure_info::_internal_set_front_theta(float value) {
  _has_bits_[0] |= 0x00000080u;
  front_theta_ = value;
}
inline void measure_info::set_front_theta(float value) {
  _internal_set_front_theta(value);
  // @@protoc_insertion_point(field_set:measure_info.front_theta)
}

// required int32 border_statu = 9 [default = 0];
inline bool measure_info::_internal_has_border_statu() const {
  bool value = (_has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool measure_info::has_border_statu() const {
  return _internal_has_border_statu();
}
inline void measure_info::clear_border_statu() {
  border_statu_ = 0;
  _has_bits_[0] &= ~0x00000100u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 measure_info::_internal_border_statu() const {
  return border_statu_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 measure_info::border_statu() const {
  // @@protoc_insertion_point(field_get:measure_info.border_statu)
  return _internal_border_statu();
}
inline void measure_info::_internal_set_border_statu(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000100u;
  border_statu_ = value;
}
inline void measure_info::set_border_statu(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_border_statu(value);
  // @@protoc_insertion_point(field_set:measure_info.border_statu)
}

// required int32 ground_status = 10 [default = 1];
inline bool measure_info::_internal_has_ground_status() const {
  bool value = (_has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool measure_info::has_ground_status() const {
  return _internal_has_ground_status();
}
inline void measure_info::clear_ground_status() {
  ground_status_ = 1;
  _has_bits_[0] &= ~0x00000200u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 measure_info::_internal_ground_status() const {
  return ground_status_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 measure_info::ground_status() const {
  // @@protoc_insertion_point(field_get:measure_info.ground_status)
  return _internal_ground_status();
}
inline void measure_info::_internal_set_ground_status(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000200u;
  ground_status_ = value;
}
inline void measure_info::set_ground_status(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_ground_status(value);
  // @@protoc_insertion_point(field_set:measure_info.ground_status)
}

// required int32 is_stop = 11 [default = 2];
inline bool measure_info::_internal_has_is_stop() const {
  bool value = (_has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool measure_info::has_is_stop() const {
  return _internal_has_is_stop();
}
inline void measure_info::clear_is_stop() {
  is_stop_ = 2;
  _has_bits_[0] &= ~0x00000400u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 measure_info::_internal_is_stop() const {
  return is_stop_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 measure_info::is_stop() const {
  // @@protoc_insertion_point(field_get:measure_info.is_stop)
  return _internal_is_stop();
}
inline void measure_info::_internal_set_is_stop(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000400u;
  is_stop_ = value;
}
inline void measure_info::set_is_stop(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_is_stop(value);
  // @@protoc_insertion_point(field_set:measure_info.is_stop)
}

// -------------------------------------------------------------------

// measure_statu

// required .measure_info info = 1;
inline bool measure_statu::_internal_has_info() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || info_ != nullptr);
  return value;
}
inline bool measure_statu::has_info() const {
  return _internal_has_info();
}
inline void measure_statu::clear_info() {
  if (info_ != nullptr) info_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::measure_info& measure_statu::_internal_info() const {
  const ::measure_info* p = info_;
  return p != nullptr ? *p : *reinterpret_cast<const ::measure_info*>(
      &::_measure_info_default_instance_);
}
inline const ::measure_info& measure_statu::info() const {
  // @@protoc_insertion_point(field_get:measure_statu.info)
  return _internal_info();
}
inline void measure_statu::unsafe_arena_set_allocated_info(
    ::measure_info* info) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(info_);
  }
  info_ = info;
  if (info) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:measure_statu.info)
}
inline ::measure_info* measure_statu::release_info() {
  _has_bits_[0] &= ~0x00000001u;
  ::measure_info* temp = info_;
  info_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::measure_info* measure_statu::unsafe_arena_release_info() {
  // @@protoc_insertion_point(field_release:measure_statu.info)
  _has_bits_[0] &= ~0x00000001u;
  ::measure_info* temp = info_;
  info_ = nullptr;
  return temp;
}
inline ::measure_info* measure_statu::_internal_mutable_info() {
  _has_bits_[0] |= 0x00000001u;
  if (info_ == nullptr) {
    auto* p = CreateMaybeMessage<::measure_info>(GetArena());
    info_ = p;
  }
  return info_;
}
inline ::measure_info* measure_statu::mutable_info() {
  // @@protoc_insertion_point(field_mutable:measure_statu.info)
  return _internal_mutable_info();
}
inline void measure_statu::set_allocated_info(::measure_info* info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete info_;
  }
  if (info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(info);
    if (message_arena != submessage_arena) {
      info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, info, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  info_ = info;
  // @@protoc_insertion_point(field_set_allocated:measure_statu.info)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)


PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::Range_status> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Range_status>() {
  return ::Range_status_descriptor();
}
template <> struct is_proto_enum< ::Ground_statu> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Ground_statu>() {
  return ::Ground_statu_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_define_2eproto
