LidarMeasure/wj_lidar/globalmsg.pb.h

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

#ifndef GOOGLE_PROTOBUF_INCLUDED_globalmsg_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_globalmsg_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3013000
#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 3013000 < 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_globalmsg_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_globalmsg_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[6]
    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_globalmsg_2eproto;
namespace globalmsg {
class SysMsg;
class SysMsgDefaultTypeInternal;
extern SysMsgDefaultTypeInternal _SysMsg_default_instance_;
class algMsg;
class algMsgDefaultTypeInternal;
extern algMsgDefaultTypeInternal _algMsg_default_instance_;
class laserMsg;
class laserMsgDefaultTypeInternal;
extern laserMsgDefaultTypeInternal _laserMsg_default_instance_;
class msg;
class msgDefaultTypeInternal;
extern msgDefaultTypeInternal _msg_default_instance_;
class plcMsg;
class plcMsgDefaultTypeInternal;
extern plcMsgDefaultTypeInternal _plcMsg_default_instance_;
class resultInfo;
class resultInfoDefaultTypeInternal;
extern resultInfoDefaultTypeInternal _resultInfo_default_instance_;
}  // namespace globalmsg
PROTOBUF_NAMESPACE_OPEN
template<> ::globalmsg::SysMsg* Arena::CreateMaybeMessage<::globalmsg::SysMsg>(Arena*);
template<> ::globalmsg::algMsg* Arena::CreateMaybeMessage<::globalmsg::algMsg>(Arena*);
template<> ::globalmsg::laserMsg* Arena::CreateMaybeMessage<::globalmsg::laserMsg>(Arena*);
template<> ::globalmsg::msg* Arena::CreateMaybeMessage<::globalmsg::msg>(Arena*);
template<> ::globalmsg::plcMsg* Arena::CreateMaybeMessage<::globalmsg::plcMsg>(Arena*);
template<> ::globalmsg::resultInfo* Arena::CreateMaybeMessage<::globalmsg::resultInfo>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace globalmsg {

enum type : int {
  ePLC = 0,
  eLaser = 1,
  eAlg = 2,
  eLog = 3
};
bool type_IsValid(int value);
constexpr type type_MIN = ePLC;
constexpr type type_MAX = eLog;
constexpr int type_ARRAYSIZE = type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* type_descriptor();
template<typename T>
inline const std::string& type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    type_descriptor(), enum_t_value);
}
inline bool type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<type>(
    type_descriptor(), name, value);
}
enum laserStatus : int {
  eLaserConnected = 0,
  eLaserDisconnected = 1,
  eLaserBusy = 2,
  eLaserUnknown = 3
};
bool laserStatus_IsValid(int value);
constexpr laserStatus laserStatus_MIN = eLaserConnected;
constexpr laserStatus laserStatus_MAX = eLaserUnknown;
constexpr int laserStatus_ARRAYSIZE = laserStatus_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* laserStatus_descriptor();
template<typename T>
inline const std::string& laserStatus_Name(T enum_t_value) {
  static_assert(::std::is_same<T, laserStatus>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function laserStatus_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    laserStatus_descriptor(), enum_t_value);
}
inline bool laserStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, laserStatus* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<laserStatus>(
    laserStatus_descriptor(), name, value);
}
enum plcStatus : int {
  ePLCConnected = 0,
  ePLCDisconnected = 1,
  ePLCRefused = 2,
  ePLCUnknown = 3
};
bool plcStatus_IsValid(int value);
constexpr plcStatus plcStatus_MIN = ePLCConnected;
constexpr plcStatus plcStatus_MAX = ePLCUnknown;
constexpr int plcStatus_ARRAYSIZE = plcStatus_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* plcStatus_descriptor();
template<typename T>
inline const std::string& plcStatus_Name(T enum_t_value) {
  static_assert(::std::is_same<T, plcStatus>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function plcStatus_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    plcStatus_descriptor(), enum_t_value);
}
inline bool plcStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, plcStatus* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<plcStatus>(
    plcStatus_descriptor(), name, value);
}
enum logLevel : int {
  eSysInfo = 0,
  eSysLog = 1,
  eSysWarning = 2,
  eSysError = 3
};
bool logLevel_IsValid(int value);
constexpr logLevel logLevel_MIN = eSysInfo;
constexpr logLevel logLevel_MAX = eSysError;
constexpr int logLevel_ARRAYSIZE = logLevel_MAX + 1;

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

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

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

  inline msg& operator=(const msg& from) {
    CopyFrom(from);
    return *this;
  }
  inline msg& operator=(msg&& 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 msg& default_instance();

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

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

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

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

  msg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<msg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const msg& from);
  void MergeFrom(const msg& 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(msg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "globalmsg.msg";
  }
  protected:
  explicit msg(::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_globalmsg_2eproto);
    return ::descriptor_table_globalmsg_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kLaserMsgFieldNumber = 2,
    kPlcMsgFieldNumber = 3,
    kAlgMsgFieldNumber = 4,
    kSysMsgFieldNumber = 5,
    kMsgTypeFieldNumber = 1,
  };
  // optional .globalmsg.laserMsg laser_msg = 2;
  bool has_laser_msg() const;
  private:
  bool _internal_has_laser_msg() const;
  public:
  void clear_laser_msg();
  const ::globalmsg::laserMsg& laser_msg() const;
  ::globalmsg::laserMsg* release_laser_msg();
  ::globalmsg::laserMsg* mutable_laser_msg();
  void set_allocated_laser_msg(::globalmsg::laserMsg* laser_msg);
  private:
  const ::globalmsg::laserMsg& _internal_laser_msg() const;
  ::globalmsg::laserMsg* _internal_mutable_laser_msg();
  public:
  void unsafe_arena_set_allocated_laser_msg(
      ::globalmsg::laserMsg* laser_msg);
  ::globalmsg::laserMsg* unsafe_arena_release_laser_msg();

  // optional .globalmsg.plcMsg plc_msg = 3;
  bool has_plc_msg() const;
  private:
  bool _internal_has_plc_msg() const;
  public:
  void clear_plc_msg();
  const ::globalmsg::plcMsg& plc_msg() const;
  ::globalmsg::plcMsg* release_plc_msg();
  ::globalmsg::plcMsg* mutable_plc_msg();
  void set_allocated_plc_msg(::globalmsg::plcMsg* plc_msg);
  private:
  const ::globalmsg::plcMsg& _internal_plc_msg() const;
  ::globalmsg::plcMsg* _internal_mutable_plc_msg();
  public:
  void unsafe_arena_set_allocated_plc_msg(
      ::globalmsg::plcMsg* plc_msg);
  ::globalmsg::plcMsg* unsafe_arena_release_plc_msg();

  // optional .globalmsg.algMsg alg_msg = 4;
  bool has_alg_msg() const;
  private:
  bool _internal_has_alg_msg() const;
  public:
  void clear_alg_msg();
  const ::globalmsg::algMsg& alg_msg() const;
  ::globalmsg::algMsg* release_alg_msg();
  ::globalmsg::algMsg* mutable_alg_msg();
  void set_allocated_alg_msg(::globalmsg::algMsg* alg_msg);
  private:
  const ::globalmsg::algMsg& _internal_alg_msg() const;
  ::globalmsg::algMsg* _internal_mutable_alg_msg();
  public:
  void unsafe_arena_set_allocated_alg_msg(
      ::globalmsg::algMsg* alg_msg);
  ::globalmsg::algMsg* unsafe_arena_release_alg_msg();

  // optional .globalmsg.SysMsg sys_msg = 5;
  bool has_sys_msg() const;
  private:
  bool _internal_has_sys_msg() const;
  public:
  void clear_sys_msg();
  const ::globalmsg::SysMsg& sys_msg() const;
  ::globalmsg::SysMsg* release_sys_msg();
  ::globalmsg::SysMsg* mutable_sys_msg();
  void set_allocated_sys_msg(::globalmsg::SysMsg* sys_msg);
  private:
  const ::globalmsg::SysMsg& _internal_sys_msg() const;
  ::globalmsg::SysMsg* _internal_mutable_sys_msg();
  public:
  void unsafe_arena_set_allocated_sys_msg(
      ::globalmsg::SysMsg* sys_msg);
  ::globalmsg::SysMsg* unsafe_arena_release_sys_msg();

  // required .globalmsg.type msg_type = 1;
  bool has_msg_type() const;
  private:
  bool _internal_has_msg_type() const;
  public:
  void clear_msg_type();
  ::globalmsg::type msg_type() const;
  void set_msg_type(::globalmsg::type value);
  private:
  ::globalmsg::type _internal_msg_type() const;
  void _internal_set_msg_type(::globalmsg::type value);
  public:

  // @@protoc_insertion_point(class_scope:globalmsg.msg)
 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_;
  ::globalmsg::laserMsg* laser_msg_;
  ::globalmsg::plcMsg* plc_msg_;
  ::globalmsg::algMsg* alg_msg_;
  ::globalmsg::SysMsg* sys_msg_;
  int msg_type_;
  friend struct ::TableStruct_globalmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline laserMsg& operator=(const laserMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline laserMsg& operator=(laserMsg&& 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 laserMsg& default_instance();

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

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

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

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

  laserMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<laserMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const laserMsg& from);
  void MergeFrom(const laserMsg& 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(laserMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "globalmsg.laserMsg";
  }
  protected:
  explicit laserMsg(::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_globalmsg_2eproto);
    return ::descriptor_table_globalmsg_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kLaserStatusFieldNumber = 1,
    kQueueDataCountFieldNumber = 2,
    kCloudCountFieldNumber = 3,
    kIdFieldNumber = 4,
  };
  // optional .globalmsg.laserStatus laser_status = 1;
  bool has_laser_status() const;
  private:
  bool _internal_has_laser_status() const;
  public:
  void clear_laser_status();
  ::globalmsg::laserStatus laser_status() const;
  void set_laser_status(::globalmsg::laserStatus value);
  private:
  ::globalmsg::laserStatus _internal_laser_status() const;
  void _internal_set_laser_status(::globalmsg::laserStatus value);
  public:

  // optional int32 queue_data_count = 2;
  bool has_queue_data_count() const;
  private:
  bool _internal_has_queue_data_count() const;
  public:
  void clear_queue_data_count();
  ::PROTOBUF_NAMESPACE_ID::int32 queue_data_count() const;
  void set_queue_data_count(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_queue_data_count() const;
  void _internal_set_queue_data_count(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional int32 cloud_count = 3;
  bool has_cloud_count() const;
  private:
  bool _internal_has_cloud_count() const;
  public:
  void clear_cloud_count();
  ::PROTOBUF_NAMESPACE_ID::int32 cloud_count() const;
  void set_cloud_count(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_cloud_count() const;
  void _internal_set_cloud_count(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // required int32 id = 4;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  ::PROTOBUF_NAMESPACE_ID::int32 id() const;
  void set_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_id() const;
  void _internal_set_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:globalmsg.laserMsg)
 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_;
  int laser_status_;
  ::PROTOBUF_NAMESPACE_ID::int32 queue_data_count_;
  ::PROTOBUF_NAMESPACE_ID::int32 cloud_count_;
  ::PROTOBUF_NAMESPACE_ID::int32 id_;
  friend struct ::TableStruct_globalmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline plcMsg& operator=(const plcMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline plcMsg& operator=(plcMsg&& 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 plcMsg& default_instance();

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

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

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

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

  plcMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<plcMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const plcMsg& from);
  void MergeFrom(const plcMsg& 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(plcMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "globalmsg.plcMsg";
  }
  protected:
  explicit plcMsg(::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_globalmsg_2eproto);
    return ::descriptor_table_globalmsg_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kPlcValuesFieldNumber = 2,
    kPlcStatusFieldNumber = 1,
  };
  // repeated int32 plc_values = 2;
  int plc_values_size() const;
  private:
  int _internal_plc_values_size() const;
  public:
  void clear_plc_values();
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_plc_values(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
      _internal_plc_values() const;
  void _internal_add_plc_values(::PROTOBUF_NAMESPACE_ID::int32 value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
      _internal_mutable_plc_values();
  public:
  ::PROTOBUF_NAMESPACE_ID::int32 plc_values(int index) const;
  void set_plc_values(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
  void add_plc_values(::PROTOBUF_NAMESPACE_ID::int32 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
      plc_values() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
      mutable_plc_values();

  // optional .globalmsg.plcStatus plc_status = 1;
  bool has_plc_status() const;
  private:
  bool _internal_has_plc_status() const;
  public:
  void clear_plc_status();
  ::globalmsg::plcStatus plc_status() const;
  void set_plc_status(::globalmsg::plcStatus value);
  private:
  ::globalmsg::plcStatus _internal_plc_status() const;
  void _internal_set_plc_status(::globalmsg::plcStatus value);
  public:

  // @@protoc_insertion_point(class_scope:globalmsg.plcMsg)
 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_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > plc_values_;
  int plc_status_;
  friend struct ::TableStruct_globalmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline resultInfo& operator=(const resultInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline resultInfo& operator=(resultInfo&& 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 resultInfo& default_instance();

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

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

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

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

  resultInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<resultInfo>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const resultInfo& from);
  void MergeFrom(const resultInfo& 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(resultInfo* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "globalmsg.resultInfo";
  }
  protected:
  explicit resultInfo(::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_globalmsg_2eproto);
    return ::descriptor_table_globalmsg_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kTimeFieldNumber = 1,
    kErrorFieldNumber = 12,
    kCorrectnessFieldNumber = 2,
    kParkSpaceIdFieldNumber = 3,
    kXFieldNumber = 5,
    kYFieldNumber = 6,
    kCFieldNumber = 7,
    kWheelBaseFieldNumber = 8,
    kLengthFieldNumber = 9,
    kWidthFieldNumber = 10,
    kHeightFieldNumber = 11,
    kFrontThetaFieldNumber = 13,
    kLaserIdsFieldNumber = 4,
  };
  // required string time = 1 [default = ""];
  bool has_time() const;
  private:
  bool _internal_has_time() const;
  public:
  void clear_time();
  const std::string& time() const;
  void set_time(const std::string& value);
  void set_time(std::string&& value);
  void set_time(const char* value);
  void set_time(const char* value, size_t size);
  std::string* mutable_time();
  std::string* release_time();
  void set_allocated_time(std::string* time);
  private:
  const std::string& _internal_time() const;
  void _internal_set_time(const std::string& value);
  std::string* _internal_mutable_time();
  public:

  // optional string error = 12 [default = ""];
  bool has_error() const;
  private:
  bool _internal_has_error() const;
  public:
  void clear_error();
  const std::string& error() const;
  void set_error(const std::string& value);
  void set_error(std::string&& value);
  void set_error(const char* value);
  void set_error(const char* value, size_t size);
  std::string* mutable_error();
  std::string* release_error();
  void set_allocated_error(std::string* error);
  private:
  const std::string& _internal_error() const;
  void _internal_set_error(const std::string& value);
  std::string* _internal_mutable_error();
  public:

  // required bool correctness = 2;
  bool has_correctness() const;
  private:
  bool _internal_has_correctness() const;
  public:
  void clear_correctness();
  bool correctness() const;
  void set_correctness(bool value);
  private:
  bool _internal_correctness() const;
  void _internal_set_correctness(bool value);
  public:

  // optional int32 park_space_id = 3;
  bool has_park_space_id() const;
  private:
  bool _internal_has_park_space_id() const;
  public:
  void clear_park_space_id();
  ::PROTOBUF_NAMESPACE_ID::int32 park_space_id() const;
  void set_park_space_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_park_space_id() const;
  void _internal_set_park_space_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional double x = 5;
  bool has_x() const;
  private:
  bool _internal_has_x() const;
  public:
  void clear_x();
  double x() const;
  void set_x(double value);
  private:
  double _internal_x() const;
  void _internal_set_x(double value);
  public:

  // optional double y = 6;
  bool has_y() const;
  private:
  bool _internal_has_y() const;
  public:
  void clear_y();
  double y() const;
  void set_y(double value);
  private:
  double _internal_y() const;
  void _internal_set_y(double value);
  public:

  // optional double c = 7;
  bool has_c() const;
  private:
  bool _internal_has_c() const;
  public:
  void clear_c();
  double c() const;
  void set_c(double value);
  private:
  double _internal_c() const;
  void _internal_set_c(double value);
  public:

  // optional double wheel_base = 8;
  bool has_wheel_base() const;
  private:
  bool _internal_has_wheel_base() const;
  public:
  void clear_wheel_base();
  double wheel_base() const;
  void set_wheel_base(double value);
  private:
  double _internal_wheel_base() const;
  void _internal_set_wheel_base(double value);
  public:

  // optional double length = 9;
  bool has_length() const;
  private:
  bool _internal_has_length() const;
  public:
  void clear_length();
  double length() const;
  void set_length(double value);
  private:
  double _internal_length() const;
  void _internal_set_length(double value);
  public:

  // optional double width = 10;
  bool has_width() const;
  private:
  bool _internal_has_width() const;
  public:
  void clear_width();
  double width() const;
  void set_width(double value);
  private:
  double _internal_width() const;
  void _internal_set_width(double value);
  public:

  // optional double height = 11;
  bool has_height() const;
  private:
  bool _internal_has_height() const;
  public:
  void clear_height();
  double height() const;
  void set_height(double value);
  private:
  double _internal_height() const;
  void _internal_set_height(double value);
  public:

  // optional double front_theta = 13;
  bool has_front_theta() const;
  private:
  bool _internal_has_front_theta() const;
  public:
  void clear_front_theta();
  double front_theta() const;
  void set_front_theta(double value);
  private:
  double _internal_front_theta() const;
  void _internal_set_front_theta(double value);
  public:

  // optional int32 laser_ids = 4;
  bool has_laser_ids() const;
  private:
  bool _internal_has_laser_ids() const;
  public:
  void clear_laser_ids();
  ::PROTOBUF_NAMESPACE_ID::int32 laser_ids() const;
  void set_laser_ids(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_laser_ids() const;
  void _internal_set_laser_ids(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:globalmsg.resultInfo)
 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::internal::ArenaStringPtr time_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr error_;
  bool correctness_;
  ::PROTOBUF_NAMESPACE_ID::int32 park_space_id_;
  double x_;
  double y_;
  double c_;
  double wheel_base_;
  double length_;
  double width_;
  double height_;
  double front_theta_;
  ::PROTOBUF_NAMESPACE_ID::int32 laser_ids_;
  friend struct ::TableStruct_globalmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline algMsg& operator=(const algMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline algMsg& operator=(algMsg&& 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 algMsg& default_instance();

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

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

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

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

  algMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<algMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const algMsg& from);
  void MergeFrom(const algMsg& 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(algMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "globalmsg.algMsg";
  }
  protected:
  explicit algMsg(::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_globalmsg_2eproto);
    return ::descriptor_table_globalmsg_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kResultFieldNumber = 1,
    kLogPathFieldNumber = 3,
    kThreadQueueSizeFieldNumber = 2,
  };
  // repeated .globalmsg.resultInfo result = 1;
  int result_size() const;
  private:
  int _internal_result_size() const;
  public:
  void clear_result();
  ::globalmsg::resultInfo* mutable_result(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::globalmsg::resultInfo >*
      mutable_result();
  private:
  const ::globalmsg::resultInfo& _internal_result(int index) const;
  ::globalmsg::resultInfo* _internal_add_result();
  public:
  const ::globalmsg::resultInfo& result(int index) const;
  ::globalmsg::resultInfo* add_result();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::globalmsg::resultInfo >&
      result() const;

  // optional string log_path = 3 [default = ""];
  bool has_log_path() const;
  private:
  bool _internal_has_log_path() const;
  public:
  void clear_log_path();
  const std::string& log_path() const;
  void set_log_path(const std::string& value);
  void set_log_path(std::string&& value);
  void set_log_path(const char* value);
  void set_log_path(const char* value, size_t size);
  std::string* mutable_log_path();
  std::string* release_log_path();
  void set_allocated_log_path(std::string* log_path);
  private:
  const std::string& _internal_log_path() const;
  void _internal_set_log_path(const std::string& value);
  std::string* _internal_mutable_log_path();
  public:

  // optional int32 thread_queue_size = 2;
  bool has_thread_queue_size() const;
  private:
  bool _internal_has_thread_queue_size() const;
  public:
  void clear_thread_queue_size();
  ::PROTOBUF_NAMESPACE_ID::int32 thread_queue_size() const;
  void set_thread_queue_size(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_thread_queue_size() const;
  void _internal_set_thread_queue_size(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:globalmsg.algMsg)
 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_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::globalmsg::resultInfo > result_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr log_path_;
  ::PROTOBUF_NAMESPACE_ID::int32 thread_queue_size_;
  friend struct ::TableStruct_globalmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline SysMsg& operator=(const SysMsg& from) {
    CopyFrom(from);
    return *this;
  }
  inline SysMsg& operator=(SysMsg&& 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 SysMsg& default_instance();

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

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

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

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

  SysMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SysMsg>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SysMsg& from);
  void MergeFrom(const SysMsg& 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(SysMsg* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "globalmsg.SysMsg";
  }
  protected:
  explicit SysMsg(::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_globalmsg_2eproto);
    return ::descriptor_table_globalmsg_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kLogFieldNumber = 1,
    kLevelFieldNumber = 2,
  };
  // required string log = 1 [default = ""];
  bool has_log() const;
  private:
  bool _internal_has_log() const;
  public:
  void clear_log();
  const std::string& log() const;
  void set_log(const std::string& value);
  void set_log(std::string&& value);
  void set_log(const char* value);
  void set_log(const char* value, size_t size);
  std::string* mutable_log();
  std::string* release_log();
  void set_allocated_log(std::string* log);
  private:
  const std::string& _internal_log() const;
  void _internal_set_log(const std::string& value);
  std::string* _internal_mutable_log();
  public:

  // optional .globalmsg.logLevel level = 2 [default = eSysInfo];
  bool has_level() const;
  private:
  bool _internal_has_level() const;
  public:
  void clear_level();
  ::globalmsg::logLevel level() const;
  void set_level(::globalmsg::logLevel value);
  private:
  ::globalmsg::logLevel _internal_level() const;
  void _internal_set_level(::globalmsg::logLevel value);
  public:

  // @@protoc_insertion_point(class_scope:globalmsg.SysMsg)
 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_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr log_;
  int level_;
  friend struct ::TableStruct_globalmsg_2eproto;
};
// ===================================================================


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

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

// required .globalmsg.type msg_type = 1;
inline bool msg::_internal_has_msg_type() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool msg::has_msg_type() const {
  return _internal_has_msg_type();
}
inline void msg::clear_msg_type() {
  msg_type_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::globalmsg::type msg::_internal_msg_type() const {
  return static_cast< ::globalmsg::type >(msg_type_);
}
inline ::globalmsg::type msg::msg_type() const {
  // @@protoc_insertion_point(field_get:globalmsg.msg.msg_type)
  return _internal_msg_type();
}
inline void msg::_internal_set_msg_type(::globalmsg::type value) {
  assert(::globalmsg::type_IsValid(value));
  _has_bits_[0] |= 0x00000010u;
  msg_type_ = value;
}
inline void msg::set_msg_type(::globalmsg::type value) {
  _internal_set_msg_type(value);
  // @@protoc_insertion_point(field_set:globalmsg.msg.msg_type)
}

// optional .globalmsg.laserMsg laser_msg = 2;
inline bool msg::_internal_has_laser_msg() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || laser_msg_ != nullptr);
  return value;
}
inline bool msg::has_laser_msg() const {
  return _internal_has_laser_msg();
}
inline void msg::clear_laser_msg() {
  if (laser_msg_ != nullptr) laser_msg_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::globalmsg::laserMsg& msg::_internal_laser_msg() const {
  const ::globalmsg::laserMsg* p = laser_msg_;
  return p != nullptr ? *p : *reinterpret_cast<const ::globalmsg::laserMsg*>(
      &::globalmsg::_laserMsg_default_instance_);
}
inline const ::globalmsg::laserMsg& msg::laser_msg() const {
  // @@protoc_insertion_point(field_get:globalmsg.msg.laser_msg)
  return _internal_laser_msg();
}
inline void msg::unsafe_arena_set_allocated_laser_msg(
    ::globalmsg::laserMsg* laser_msg) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(laser_msg_);
  }
  laser_msg_ = laser_msg;
  if (laser_msg) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:globalmsg.msg.laser_msg)
}
inline ::globalmsg::laserMsg* msg::release_laser_msg() {
  _has_bits_[0] &= ~0x00000001u;
  ::globalmsg::laserMsg* temp = laser_msg_;
  laser_msg_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::globalmsg::laserMsg* msg::unsafe_arena_release_laser_msg() {
  // @@protoc_insertion_point(field_release:globalmsg.msg.laser_msg)
  _has_bits_[0] &= ~0x00000001u;
  ::globalmsg::laserMsg* temp = laser_msg_;
  laser_msg_ = nullptr;
  return temp;
}
inline ::globalmsg::laserMsg* msg::_internal_mutable_laser_msg() {
  _has_bits_[0] |= 0x00000001u;
  if (laser_msg_ == nullptr) {
    auto* p = CreateMaybeMessage<::globalmsg::laserMsg>(GetArena());
    laser_msg_ = p;
  }
  return laser_msg_;
}
inline ::globalmsg::laserMsg* msg::mutable_laser_msg() {
  // @@protoc_insertion_point(field_mutable:globalmsg.msg.laser_msg)
  return _internal_mutable_laser_msg();
}
inline void msg::set_allocated_laser_msg(::globalmsg::laserMsg* laser_msg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete laser_msg_;
  }
  if (laser_msg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(laser_msg);
    if (message_arena != submessage_arena) {
      laser_msg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, laser_msg, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  laser_msg_ = laser_msg;
  // @@protoc_insertion_point(field_set_allocated:globalmsg.msg.laser_msg)
}

// optional .globalmsg.plcMsg plc_msg = 3;
inline bool msg::_internal_has_plc_msg() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || plc_msg_ != nullptr);
  return value;
}
inline bool msg::has_plc_msg() const {
  return _internal_has_plc_msg();
}
inline void msg::clear_plc_msg() {
  if (plc_msg_ != nullptr) plc_msg_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::globalmsg::plcMsg& msg::_internal_plc_msg() const {
  const ::globalmsg::plcMsg* p = plc_msg_;
  return p != nullptr ? *p : *reinterpret_cast<const ::globalmsg::plcMsg*>(
      &::globalmsg::_plcMsg_default_instance_);
}
inline const ::globalmsg::plcMsg& msg::plc_msg() const {
  // @@protoc_insertion_point(field_get:globalmsg.msg.plc_msg)
  return _internal_plc_msg();
}
inline void msg::unsafe_arena_set_allocated_plc_msg(
    ::globalmsg::plcMsg* plc_msg) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(plc_msg_);
  }
  plc_msg_ = plc_msg;
  if (plc_msg) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:globalmsg.msg.plc_msg)
}
inline ::globalmsg::plcMsg* msg::release_plc_msg() {
  _has_bits_[0] &= ~0x00000002u;
  ::globalmsg::plcMsg* temp = plc_msg_;
  plc_msg_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::globalmsg::plcMsg* msg::unsafe_arena_release_plc_msg() {
  // @@protoc_insertion_point(field_release:globalmsg.msg.plc_msg)
  _has_bits_[0] &= ~0x00000002u;
  ::globalmsg::plcMsg* temp = plc_msg_;
  plc_msg_ = nullptr;
  return temp;
}
inline ::globalmsg::plcMsg* msg::_internal_mutable_plc_msg() {
  _has_bits_[0] |= 0x00000002u;
  if (plc_msg_ == nullptr) {
    auto* p = CreateMaybeMessage<::globalmsg::plcMsg>(GetArena());
    plc_msg_ = p;
  }
  return plc_msg_;
}
inline ::globalmsg::plcMsg* msg::mutable_plc_msg() {
  // @@protoc_insertion_point(field_mutable:globalmsg.msg.plc_msg)
  return _internal_mutable_plc_msg();
}
inline void msg::set_allocated_plc_msg(::globalmsg::plcMsg* plc_msg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete plc_msg_;
  }
  if (plc_msg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(plc_msg);
    if (message_arena != submessage_arena) {
      plc_msg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, plc_msg, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  plc_msg_ = plc_msg;
  // @@protoc_insertion_point(field_set_allocated:globalmsg.msg.plc_msg)
}

// optional .globalmsg.algMsg alg_msg = 4;
inline bool msg::_internal_has_alg_msg() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || alg_msg_ != nullptr);
  return value;
}
inline bool msg::has_alg_msg() const {
  return _internal_has_alg_msg();
}
inline void msg::clear_alg_msg() {
  if (alg_msg_ != nullptr) alg_msg_->Clear();
  _has_bits_[0] &= ~0x00000004u;
}
inline const ::globalmsg::algMsg& msg::_internal_alg_msg() const {
  const ::globalmsg::algMsg* p = alg_msg_;
  return p != nullptr ? *p : *reinterpret_cast<const ::globalmsg::algMsg*>(
      &::globalmsg::_algMsg_default_instance_);
}
inline const ::globalmsg::algMsg& msg::alg_msg() const {
  // @@protoc_insertion_point(field_get:globalmsg.msg.alg_msg)
  return _internal_alg_msg();
}
inline void msg::unsafe_arena_set_allocated_alg_msg(
    ::globalmsg::algMsg* alg_msg) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(alg_msg_);
  }
  alg_msg_ = alg_msg;
  if (alg_msg) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:globalmsg.msg.alg_msg)
}
inline ::globalmsg::algMsg* msg::release_alg_msg() {
  _has_bits_[0] &= ~0x00000004u;
  ::globalmsg::algMsg* temp = alg_msg_;
  alg_msg_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::globalmsg::algMsg* msg::unsafe_arena_release_alg_msg() {
  // @@protoc_insertion_point(field_release:globalmsg.msg.alg_msg)
  _has_bits_[0] &= ~0x00000004u;
  ::globalmsg::algMsg* temp = alg_msg_;
  alg_msg_ = nullptr;
  return temp;
}
inline ::globalmsg::algMsg* msg::_internal_mutable_alg_msg() {
  _has_bits_[0] |= 0x00000004u;
  if (alg_msg_ == nullptr) {
    auto* p = CreateMaybeMessage<::globalmsg::algMsg>(GetArena());
    alg_msg_ = p;
  }
  return alg_msg_;
}
inline ::globalmsg::algMsg* msg::mutable_alg_msg() {
  // @@protoc_insertion_point(field_mutable:globalmsg.msg.alg_msg)
  return _internal_mutable_alg_msg();
}
inline void msg::set_allocated_alg_msg(::globalmsg::algMsg* alg_msg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete alg_msg_;
  }
  if (alg_msg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(alg_msg);
    if (message_arena != submessage_arena) {
      alg_msg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, alg_msg, submessage_arena);
    }
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  alg_msg_ = alg_msg;
  // @@protoc_insertion_point(field_set_allocated:globalmsg.msg.alg_msg)
}

// optional .globalmsg.SysMsg sys_msg = 5;
inline bool msg::_internal_has_sys_msg() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || sys_msg_ != nullptr);
  return value;
}
inline bool msg::has_sys_msg() const {
  return _internal_has_sys_msg();
}
inline void msg::clear_sys_msg() {
  if (sys_msg_ != nullptr) sys_msg_->Clear();
  _has_bits_[0] &= ~0x00000008u;
}
inline const ::globalmsg::SysMsg& msg::_internal_sys_msg() const {
  const ::globalmsg::SysMsg* p = sys_msg_;
  return p != nullptr ? *p : *reinterpret_cast<const ::globalmsg::SysMsg*>(
      &::globalmsg::_SysMsg_default_instance_);
}
inline const ::globalmsg::SysMsg& msg::sys_msg() const {
  // @@protoc_insertion_point(field_get:globalmsg.msg.sys_msg)
  return _internal_sys_msg();
}
inline void msg::unsafe_arena_set_allocated_sys_msg(
    ::globalmsg::SysMsg* sys_msg) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(sys_msg_);
  }
  sys_msg_ = sys_msg;
  if (sys_msg) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:globalmsg.msg.sys_msg)
}
inline ::globalmsg::SysMsg* msg::release_sys_msg() {
  _has_bits_[0] &= ~0x00000008u;
  ::globalmsg::SysMsg* temp = sys_msg_;
  sys_msg_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::globalmsg::SysMsg* msg::unsafe_arena_release_sys_msg() {
  // @@protoc_insertion_point(field_release:globalmsg.msg.sys_msg)
  _has_bits_[0] &= ~0x00000008u;
  ::globalmsg::SysMsg* temp = sys_msg_;
  sys_msg_ = nullptr;
  return temp;
}
inline ::globalmsg::SysMsg* msg::_internal_mutable_sys_msg() {
  _has_bits_[0] |= 0x00000008u;
  if (sys_msg_ == nullptr) {
    auto* p = CreateMaybeMessage<::globalmsg::SysMsg>(GetArena());
    sys_msg_ = p;
  }
  return sys_msg_;
}
inline ::globalmsg::SysMsg* msg::mutable_sys_msg() {
  // @@protoc_insertion_point(field_mutable:globalmsg.msg.sys_msg)
  return _internal_mutable_sys_msg();
}
inline void msg::set_allocated_sys_msg(::globalmsg::SysMsg* sys_msg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete sys_msg_;
  }
  if (sys_msg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(sys_msg);
    if (message_arena != submessage_arena) {
      sys_msg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, sys_msg, submessage_arena);
    }
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  sys_msg_ = sys_msg;
  // @@protoc_insertion_point(field_set_allocated:globalmsg.msg.sys_msg)
}

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

// laserMsg

// optional .globalmsg.laserStatus laser_status = 1;
inline bool laserMsg::_internal_has_laser_status() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool laserMsg::has_laser_status() const {
  return _internal_has_laser_status();
}
inline void laserMsg::clear_laser_status() {
  laser_status_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::globalmsg::laserStatus laserMsg::_internal_laser_status() const {
  return static_cast< ::globalmsg::laserStatus >(laser_status_);
}
inline ::globalmsg::laserStatus laserMsg::laser_status() const {
  // @@protoc_insertion_point(field_get:globalmsg.laserMsg.laser_status)
  return _internal_laser_status();
}
inline void laserMsg::_internal_set_laser_status(::globalmsg::laserStatus value) {
  assert(::globalmsg::laserStatus_IsValid(value));
  _has_bits_[0] |= 0x00000001u;
  laser_status_ = value;
}
inline void laserMsg::set_laser_status(::globalmsg::laserStatus value) {
  _internal_set_laser_status(value);
  // @@protoc_insertion_point(field_set:globalmsg.laserMsg.laser_status)
}

// optional int32 queue_data_count = 2;
inline bool laserMsg::_internal_has_queue_data_count() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool laserMsg::has_queue_data_count() const {
  return _internal_has_queue_data_count();
}
inline void laserMsg::clear_queue_data_count() {
  queue_data_count_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 laserMsg::_internal_queue_data_count() const {
  return queue_data_count_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 laserMsg::queue_data_count() const {
  // @@protoc_insertion_point(field_get:globalmsg.laserMsg.queue_data_count)
  return _internal_queue_data_count();
}
inline void laserMsg::_internal_set_queue_data_count(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000002u;
  queue_data_count_ = value;
}
inline void laserMsg::set_queue_data_count(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_queue_data_count(value);
  // @@protoc_insertion_point(field_set:globalmsg.laserMsg.queue_data_count)
}

// optional int32 cloud_count = 3;
inline bool laserMsg::_internal_has_cloud_count() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool laserMsg::has_cloud_count() const {
  return _internal_has_cloud_count();
}
inline void laserMsg::clear_cloud_count() {
  cloud_count_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 laserMsg::_internal_cloud_count() const {
  return cloud_count_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 laserMsg::cloud_count() const {
  // @@protoc_insertion_point(field_get:globalmsg.laserMsg.cloud_count)
  return _internal_cloud_count();
}
inline void laserMsg::_internal_set_cloud_count(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000004u;
  cloud_count_ = value;
}
inline void laserMsg::set_cloud_count(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_cloud_count(value);
  // @@protoc_insertion_point(field_set:globalmsg.laserMsg.cloud_count)
}

// required int32 id = 4;
inline bool laserMsg::_internal_has_id() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool laserMsg::has_id() const {
  return _internal_has_id();
}
inline void laserMsg::clear_id() {
  id_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 laserMsg::_internal_id() const {
  return id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 laserMsg::id() const {
  // @@protoc_insertion_point(field_get:globalmsg.laserMsg.id)
  return _internal_id();
}
inline void laserMsg::_internal_set_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000008u;
  id_ = value;
}
inline void laserMsg::set_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:globalmsg.laserMsg.id)
}

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

// plcMsg

// optional .globalmsg.plcStatus plc_status = 1;
inline bool plcMsg::_internal_has_plc_status() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool plcMsg::has_plc_status() const {
  return _internal_has_plc_status();
}
inline void plcMsg::clear_plc_status() {
  plc_status_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::globalmsg::plcStatus plcMsg::_internal_plc_status() const {
  return static_cast< ::globalmsg::plcStatus >(plc_status_);
}
inline ::globalmsg::plcStatus plcMsg::plc_status() const {
  // @@protoc_insertion_point(field_get:globalmsg.plcMsg.plc_status)
  return _internal_plc_status();
}
inline void plcMsg::_internal_set_plc_status(::globalmsg::plcStatus value) {
  assert(::globalmsg::plcStatus_IsValid(value));
  _has_bits_[0] |= 0x00000001u;
  plc_status_ = value;
}
inline void plcMsg::set_plc_status(::globalmsg::plcStatus value) {
  _internal_set_plc_status(value);
  // @@protoc_insertion_point(field_set:globalmsg.plcMsg.plc_status)
}

// repeated int32 plc_values = 2;
inline int plcMsg::_internal_plc_values_size() const {
  return plc_values_.size();
}
inline int plcMsg::plc_values_size() const {
  return _internal_plc_values_size();
}
inline void plcMsg::clear_plc_values() {
  plc_values_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int32 plcMsg::_internal_plc_values(int index) const {
  return plc_values_.Get(index);
}
inline ::PROTOBUF_NAMESPACE_ID::int32 plcMsg::plc_values(int index) const {
  // @@protoc_insertion_point(field_get:globalmsg.plcMsg.plc_values)
  return _internal_plc_values(index);
}
inline void plcMsg::set_plc_values(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
  plc_values_.Set(index, value);
  // @@protoc_insertion_point(field_set:globalmsg.plcMsg.plc_values)
}
inline void plcMsg::_internal_add_plc_values(::PROTOBUF_NAMESPACE_ID::int32 value) {
  plc_values_.Add(value);
}
inline void plcMsg::add_plc_values(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_add_plc_values(value);
  // @@protoc_insertion_point(field_add:globalmsg.plcMsg.plc_values)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
plcMsg::_internal_plc_values() const {
  return plc_values_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
plcMsg::plc_values() const {
  // @@protoc_insertion_point(field_list:globalmsg.plcMsg.plc_values)
  return _internal_plc_values();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
plcMsg::_internal_mutable_plc_values() {
  return &plc_values_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
plcMsg::mutable_plc_values() {
  // @@protoc_insertion_point(field_mutable_list:globalmsg.plcMsg.plc_values)
  return _internal_mutable_plc_values();
}

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

// resultInfo

// required string time = 1 [default = ""];
inline bool resultInfo::_internal_has_time() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool resultInfo::has_time() const {
  return _internal_has_time();
}
inline void resultInfo::clear_time() {
  time_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& resultInfo::time() const {
  // @@protoc_insertion_point(field_get:globalmsg.resultInfo.time)
  return _internal_time();
}
inline void resultInfo::set_time(const std::string& value) {
  _internal_set_time(value);
  // @@protoc_insertion_point(field_set:globalmsg.resultInfo.time)
}
inline std::string* resultInfo::mutable_time() {
  // @@protoc_insertion_point(field_mutable:globalmsg.resultInfo.time)
  return _internal_mutable_time();
}
inline const std::string& resultInfo::_internal_time() const {
  return time_.Get();
}
inline void resultInfo::_internal_set_time(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  time_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void resultInfo::set_time(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  time_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:globalmsg.resultInfo.time)
}
inline void resultInfo::set_time(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  time_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:globalmsg.resultInfo.time)
}
inline void resultInfo::set_time(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  time_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:globalmsg.resultInfo.time)
}
inline std::string* resultInfo::_internal_mutable_time() {
  _has_bits_[0] |= 0x00000001u;
  return time_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* resultInfo::release_time() {
  // @@protoc_insertion_point(field_release:globalmsg.resultInfo.time)
  if (!_internal_has_time()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return time_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void resultInfo::set_allocated_time(std::string* time) {
  if (time != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  time_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), time,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:globalmsg.resultInfo.time)
}

// required bool correctness = 2;
inline bool resultInfo::_internal_has_correctness() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool resultInfo::has_correctness() const {
  return _internal_has_correctness();
}
inline void resultInfo::clear_correctness() {
  correctness_ = false;
  _has_bits_[0] &= ~0x00000004u;
}
inline bool resultInfo::_internal_correctness() const {
  return correctness_;
}
inline bool resultInfo::correctness() const {
  // @@protoc_insertion_point(field_get:globalmsg.resultInfo.correctness)
  return _internal_correctness();
}
inline void resultInfo::_internal_set_correctness(bool value) {
  _has_bits_[0] |= 0x00000004u;
  correctness_ = value;
}
inline void resultInfo::set_correctness(bool value) {
  _internal_set_correctness(value);
  // @@protoc_insertion_point(field_set:globalmsg.resultInfo.correctness)
}

// optional int32 park_space_id = 3;
inline bool resultInfo::_internal_has_park_space_id() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool resultInfo::has_park_space_id() const {
  return _internal_has_park_space_id();
}
inline void resultInfo::clear_park_space_id() {
  park_space_id_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 resultInfo::_internal_park_space_id() const {
  return park_space_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 resultInfo::park_space_id() const {
  // @@protoc_insertion_point(field_get:globalmsg.resultInfo.park_space_id)
  return _internal_park_space_id();
}
inline void resultInfo::_internal_set_park_space_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000008u;
  park_space_id_ = value;
}
inline void resultInfo::set_park_space_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_park_space_id(value);
  // @@protoc_insertion_point(field_set:globalmsg.resultInfo.park_space_id)
}

// optional int32 laser_ids = 4;
inline bool resultInfo::_internal_has_laser_ids() const {
  bool value = (_has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool resultInfo::has_laser_ids() const {
  return _internal_has_laser_ids();
}
inline void resultInfo::clear_laser_ids() {
  laser_ids_ = 0;
  _has_bits_[0] &= ~0x00001000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 resultInfo::_internal_laser_ids() const {
  return laser_ids_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 resultInfo::laser_ids() const {
  // @@protoc_insertion_point(field_get:globalmsg.resultInfo.laser_ids)
  return _internal_laser_ids();
}
inline void resultInfo::_internal_set_laser_ids(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00001000u;
  laser_ids_ = value;
}
inline void resultInfo::set_laser_ids(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_laser_ids(value);
  // @@protoc_insertion_point(field_set:globalmsg.resultInfo.laser_ids)
}

// optional double x = 5;
inline bool resultInfo::_internal_has_x() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool resultInfo::has_x() const {
  return _internal_has_x();
}
inline void resultInfo::clear_x() {
  x_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline double resultInfo::_internal_x() const {
  return x_;
}
inline double resultInfo::x() const {
  // @@protoc_insertion_point(field_get:globalmsg.resultInfo.x)
  return _internal_x();
}
inline void resultInfo::_internal_set_x(double value) {
  _has_bits_[0] |= 0x00000010u;
  x_ = value;
}
inline void resultInfo::set_x(double value) {
  _internal_set_x(value);
  // @@protoc_insertion_point(field_set:globalmsg.resultInfo.x)
}

// optional double y = 6;
inline bool resultInfo::_internal_has_y() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool resultInfo::has_y() const {
  return _internal_has_y();
}
inline void resultInfo::clear_y() {
  y_ = 0;
  _has_bits_[0] &= ~0x00000020u;
}
inline double resultInfo::_internal_y() const {
  return y_;
}
inline double resultInfo::y() const {
  // @@protoc_insertion_point(field_get:globalmsg.resultInfo.y)
  return _internal_y();
}
inline void resultInfo::_internal_set_y(double value) {
  _has_bits_[0] |= 0x00000020u;
  y_ = value;
}
inline void resultInfo::set_y(double value) {
  _internal_set_y(value);
  // @@protoc_insertion_point(field_set:globalmsg.resultInfo.y)
}

// optional double c = 7;
inline bool resultInfo::_internal_has_c() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool resultInfo::has_c() const {
  return _internal_has_c();
}
inline void resultInfo::clear_c() {
  c_ = 0;
  _has_bits_[0] &= ~0x00000040u;
}
inline double resultInfo::_internal_c() const {
  return c_;
}
inline double resultInfo::c() const {
  // @@protoc_insertion_point(field_get:globalmsg.resultInfo.c)
  return _internal_c();
}
inline void resultInfo::_internal_set_c(double value) {
  _has_bits_[0] |= 0x00000040u;
  c_ = value;
}
inline void resultInfo::set_c(double value) {
  _internal_set_c(value);
  // @@protoc_insertion_point(field_set:globalmsg.resultInfo.c)
}

// optional double wheel_base = 8;
inline bool resultInfo::_internal_has_wheel_base() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool resultInfo::has_wheel_base() const {
  return _internal_has_wheel_base();
}
inline void resultInfo::clear_wheel_base() {
  wheel_base_ = 0;
  _has_bits_[0] &= ~0x00000080u;
}
inline double resultInfo::_internal_wheel_base() const {
  return wheel_base_;
}
inline double resultInfo::wheel_base() const {
  // @@protoc_insertion_point(field_get:globalmsg.resultInfo.wheel_base)
  return _internal_wheel_base();
}
inline void resultInfo::_internal_set_wheel_base(double value) {
  _has_bits_[0] |= 0x00000080u;
  wheel_base_ = value;
}
inline void resultInfo::set_wheel_base(double value) {
  _internal_set_wheel_base(value);
  // @@protoc_insertion_point(field_set:globalmsg.resultInfo.wheel_base)
}

// optional double length = 9;
inline bool resultInfo::_internal_has_length() const {
  bool value = (_has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool resultInfo::has_length() const {
  return _internal_has_length();
}
inline void resultInfo::clear_length() {
  length_ = 0;
  _has_bits_[0] &= ~0x00000100u;
}
inline double resultInfo::_internal_length() const {
  return length_;
}
inline double resultInfo::length() const {
  // @@protoc_insertion_point(field_get:globalmsg.resultInfo.length)
  return _internal_length();
}
inline void resultInfo::_internal_set_length(double value) {
  _has_bits_[0] |= 0x00000100u;
  length_ = value;
}
inline void resultInfo::set_length(double value) {
  _internal_set_length(value);
  // @@protoc_insertion_point(field_set:globalmsg.resultInfo.length)
}

// optional double width = 10;
inline bool resultInfo::_internal_has_width() const {
  bool value = (_has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool resultInfo::has_width() const {
  return _internal_has_width();
}
inline void resultInfo::clear_width() {
  width_ = 0;
  _has_bits_[0] &= ~0x00000200u;
}
inline double resultInfo::_internal_width() const {
  return width_;
}
inline double resultInfo::width() const {
  // @@protoc_insertion_point(field_get:globalmsg.resultInfo.width)
  return _internal_width();
}
inline void resultInfo::_internal_set_width(double value) {
  _has_bits_[0] |= 0x00000200u;
  width_ = value;
}
inline void resultInfo::set_width(double value) {
  _internal_set_width(value);
  // @@protoc_insertion_point(field_set:globalmsg.resultInfo.width)
}

// optional double height = 11;
inline bool resultInfo::_internal_has_height() const {
  bool value = (_has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool resultInfo::has_height() const {
  return _internal_has_height();
}
inline void resultInfo::clear_height() {
  height_ = 0;
  _has_bits_[0] &= ~0x00000400u;
}
inline double resultInfo::_internal_height() const {
  return height_;
}
inline double resultInfo::height() const {
  // @@protoc_insertion_point(field_get:globalmsg.resultInfo.height)
  return _internal_height();
}
inline void resultInfo::_internal_set_height(double value) {
  _has_bits_[0] |= 0x00000400u;
  height_ = value;
}
inline void resultInfo::set_height(double value) {
  _internal_set_height(value);
  // @@protoc_insertion_point(field_set:globalmsg.resultInfo.height)
}

// optional string error = 12 [default = ""];
inline bool resultInfo::_internal_has_error() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool resultInfo::has_error() const {
  return _internal_has_error();
}
inline void resultInfo::clear_error() {
  error_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& resultInfo::error() const {
  // @@protoc_insertion_point(field_get:globalmsg.resultInfo.error)
  return _internal_error();
}
inline void resultInfo::set_error(const std::string& value) {
  _internal_set_error(value);
  // @@protoc_insertion_point(field_set:globalmsg.resultInfo.error)
}
inline std::string* resultInfo::mutable_error() {
  // @@protoc_insertion_point(field_mutable:globalmsg.resultInfo.error)
  return _internal_mutable_error();
}
inline const std::string& resultInfo::_internal_error() const {
  return error_.Get();
}
inline void resultInfo::_internal_set_error(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  error_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void resultInfo::set_error(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  error_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:globalmsg.resultInfo.error)
}
inline void resultInfo::set_error(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  error_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:globalmsg.resultInfo.error)
}
inline void resultInfo::set_error(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000002u;
  error_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:globalmsg.resultInfo.error)
}
inline std::string* resultInfo::_internal_mutable_error() {
  _has_bits_[0] |= 0x00000002u;
  return error_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* resultInfo::release_error() {
  // @@protoc_insertion_point(field_release:globalmsg.resultInfo.error)
  if (!_internal_has_error()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return error_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void resultInfo::set_allocated_error(std::string* error) {
  if (error != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  error_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), error,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:globalmsg.resultInfo.error)
}

// optional double front_theta = 13;
inline bool resultInfo::_internal_has_front_theta() const {
  bool value = (_has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool resultInfo::has_front_theta() const {
  return _internal_has_front_theta();
}
inline void resultInfo::clear_front_theta() {
  front_theta_ = 0;
  _has_bits_[0] &= ~0x00000800u;
}
inline double resultInfo::_internal_front_theta() const {
  return front_theta_;
}
inline double resultInfo::front_theta() const {
  // @@protoc_insertion_point(field_get:globalmsg.resultInfo.front_theta)
  return _internal_front_theta();
}
inline void resultInfo::_internal_set_front_theta(double value) {
  _has_bits_[0] |= 0x00000800u;
  front_theta_ = value;
}
inline void resultInfo::set_front_theta(double value) {
  _internal_set_front_theta(value);
  // @@protoc_insertion_point(field_set:globalmsg.resultInfo.front_theta)
}

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

// algMsg

// repeated .globalmsg.resultInfo result = 1;
inline int algMsg::_internal_result_size() const {
  return result_.size();
}
inline int algMsg::result_size() const {
  return _internal_result_size();
}
inline void algMsg::clear_result() {
  result_.Clear();
}
inline ::globalmsg::resultInfo* algMsg::mutable_result(int index) {
  // @@protoc_insertion_point(field_mutable:globalmsg.algMsg.result)
  return result_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::globalmsg::resultInfo >*
algMsg::mutable_result() {
  // @@protoc_insertion_point(field_mutable_list:globalmsg.algMsg.result)
  return &result_;
}
inline const ::globalmsg::resultInfo& algMsg::_internal_result(int index) const {
  return result_.Get(index);
}
inline const ::globalmsg::resultInfo& algMsg::result(int index) const {
  // @@protoc_insertion_point(field_get:globalmsg.algMsg.result)
  return _internal_result(index);
}
inline ::globalmsg::resultInfo* algMsg::_internal_add_result() {
  return result_.Add();
}
inline ::globalmsg::resultInfo* algMsg::add_result() {
  // @@protoc_insertion_point(field_add:globalmsg.algMsg.result)
  return _internal_add_result();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::globalmsg::resultInfo >&
algMsg::result() const {
  // @@protoc_insertion_point(field_list:globalmsg.algMsg.result)
  return result_;
}

// optional int32 thread_queue_size = 2;
inline bool algMsg::_internal_has_thread_queue_size() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool algMsg::has_thread_queue_size() const {
  return _internal_has_thread_queue_size();
}
inline void algMsg::clear_thread_queue_size() {
  thread_queue_size_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 algMsg::_internal_thread_queue_size() const {
  return thread_queue_size_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 algMsg::thread_queue_size() const {
  // @@protoc_insertion_point(field_get:globalmsg.algMsg.thread_queue_size)
  return _internal_thread_queue_size();
}
inline void algMsg::_internal_set_thread_queue_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000002u;
  thread_queue_size_ = value;
}
inline void algMsg::set_thread_queue_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_thread_queue_size(value);
  // @@protoc_insertion_point(field_set:globalmsg.algMsg.thread_queue_size)
}

// optional string log_path = 3 [default = ""];
inline bool algMsg::_internal_has_log_path() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool algMsg::has_log_path() const {
  return _internal_has_log_path();
}
inline void algMsg::clear_log_path() {
  log_path_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& algMsg::log_path() const {
  // @@protoc_insertion_point(field_get:globalmsg.algMsg.log_path)
  return _internal_log_path();
}
inline void algMsg::set_log_path(const std::string& value) {
  _internal_set_log_path(value);
  // @@protoc_insertion_point(field_set:globalmsg.algMsg.log_path)
}
inline std::string* algMsg::mutable_log_path() {
  // @@protoc_insertion_point(field_mutable:globalmsg.algMsg.log_path)
  return _internal_mutable_log_path();
}
inline const std::string& algMsg::_internal_log_path() const {
  return log_path_.Get();
}
inline void algMsg::_internal_set_log_path(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  log_path_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void algMsg::set_log_path(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  log_path_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:globalmsg.algMsg.log_path)
}
inline void algMsg::set_log_path(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  log_path_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:globalmsg.algMsg.log_path)
}
inline void algMsg::set_log_path(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  log_path_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:globalmsg.algMsg.log_path)
}
inline std::string* algMsg::_internal_mutable_log_path() {
  _has_bits_[0] |= 0x00000001u;
  return log_path_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* algMsg::release_log_path() {
  // @@protoc_insertion_point(field_release:globalmsg.algMsg.log_path)
  if (!_internal_has_log_path()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return log_path_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void algMsg::set_allocated_log_path(std::string* log_path) {
  if (log_path != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  log_path_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), log_path,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:globalmsg.algMsg.log_path)
}

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

// SysMsg

// required string log = 1 [default = ""];
inline bool SysMsg::_internal_has_log() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SysMsg::has_log() const {
  return _internal_has_log();
}
inline void SysMsg::clear_log() {
  log_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SysMsg::log() const {
  // @@protoc_insertion_point(field_get:globalmsg.SysMsg.log)
  return _internal_log();
}
inline void SysMsg::set_log(const std::string& value) {
  _internal_set_log(value);
  // @@protoc_insertion_point(field_set:globalmsg.SysMsg.log)
}
inline std::string* SysMsg::mutable_log() {
  // @@protoc_insertion_point(field_mutable:globalmsg.SysMsg.log)
  return _internal_mutable_log();
}
inline const std::string& SysMsg::_internal_log() const {
  return log_.Get();
}
inline void SysMsg::_internal_set_log(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  log_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void SysMsg::set_log(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  log_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:globalmsg.SysMsg.log)
}
inline void SysMsg::set_log(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  log_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:globalmsg.SysMsg.log)
}
inline void SysMsg::set_log(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  log_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:globalmsg.SysMsg.log)
}
inline std::string* SysMsg::_internal_mutable_log() {
  _has_bits_[0] |= 0x00000001u;
  return log_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* SysMsg::release_log() {
  // @@protoc_insertion_point(field_release:globalmsg.SysMsg.log)
  if (!_internal_has_log()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return log_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SysMsg::set_allocated_log(std::string* log) {
  if (log != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  log_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), log,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:globalmsg.SysMsg.log)
}

// optional .globalmsg.logLevel level = 2 [default = eSysInfo];
inline bool SysMsg::_internal_has_level() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SysMsg::has_level() const {
  return _internal_has_level();
}
inline void SysMsg::clear_level() {
  level_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::globalmsg::logLevel SysMsg::_internal_level() const {
  return static_cast< ::globalmsg::logLevel >(level_);
}
inline ::globalmsg::logLevel SysMsg::level() const {
  // @@protoc_insertion_point(field_get:globalmsg.SysMsg.level)
  return _internal_level();
}
inline void SysMsg::_internal_set_level(::globalmsg::logLevel value) {
  assert(::globalmsg::logLevel_IsValid(value));
  _has_bits_[0] |= 0x00000002u;
  level_ = value;
}
inline void SysMsg::set_level(::globalmsg::logLevel value) {
  _internal_set_level(value);
  // @@protoc_insertion_point(field_set:globalmsg.SysMsg.level)
}

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace globalmsg

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::globalmsg::type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::globalmsg::type>() {
  return ::globalmsg::type_descriptor();
}
template <> struct is_proto_enum< ::globalmsg::laserStatus> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::globalmsg::laserStatus>() {
  return ::globalmsg::laserStatus_descriptor();
}
template <> struct is_proto_enum< ::globalmsg::plcStatus> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::globalmsg::plcStatus>() {
  return ::globalmsg::plcStatus_descriptor();
}
template <> struct is_proto_enum< ::globalmsg::logLevel> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::globalmsg::logLevel>() {
  return ::globalmsg::logLevel_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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