LidarMeasure/wj_lidar/globalmsg.pb.h

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

#ifndef PROTOBUF_globalmsg_2eproto__INCLUDED
#define PROTOBUF_globalmsg_2eproto__INCLUDED

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 3005000
#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 3005000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/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/metadata.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)

namespace protobuf_globalmsg_2eproto {
// Internal implementation detail -- do not use these members.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[6];
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static const ::google::protobuf::uint32 offsets[];
};
void AddDescriptors();
void InitDefaultsmsgImpl();
void InitDefaultsmsg();
void InitDefaultslaserMsgImpl();
void InitDefaultslaserMsg();
void InitDefaultsplcMsgImpl();
void InitDefaultsplcMsg();
void InitDefaultsresultInfoImpl();
void InitDefaultsresultInfo();
void InitDefaultsalgMsgImpl();
void InitDefaultsalgMsg();
void InitDefaultsSysMsgImpl();
void InitDefaultsSysMsg();
inline void InitDefaults() {
  InitDefaultsmsg();
  InitDefaultslaserMsg();
  InitDefaultsplcMsg();
  InitDefaultsresultInfo();
  InitDefaultsalgMsg();
  InitDefaultsSysMsg();
}
}  // namespace protobuf_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
namespace globalmsg {

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

const ::google::protobuf::EnumDescriptor* type_descriptor();
inline const ::std::string& type_Name(type value) {
  return ::google::protobuf::internal::NameOfEnum(
    type_descriptor(), value);
}
inline bool type_Parse(
    const ::std::string& name, type* value) {
  return ::google::protobuf::internal::ParseNamedEnum<type>(
    type_descriptor(), name, value);
}
enum laserStatus {
  eLaserConnected = 0,
  eLaserDisconnected = 1,
  eLaserBusy = 2,
  eLaserUnknown = 3
};
bool laserStatus_IsValid(int value);
const laserStatus laserStatus_MIN = eLaserConnected;
const laserStatus laserStatus_MAX = eLaserUnknown;
const int laserStatus_ARRAYSIZE = laserStatus_MAX + 1;

const ::google::protobuf::EnumDescriptor* laserStatus_descriptor();
inline const ::std::string& laserStatus_Name(laserStatus value) {
  return ::google::protobuf::internal::NameOfEnum(
    laserStatus_descriptor(), value);
}
inline bool laserStatus_Parse(
    const ::std::string& name, laserStatus* value) {
  return ::google::protobuf::internal::ParseNamedEnum<laserStatus>(
    laserStatus_descriptor(), name, value);
}
enum plcStatus {
  ePLCConnected = 0,
  ePLCDisconnected = 1,
  ePLCRefused = 2,
  ePLCUnknown = 3
};
bool plcStatus_IsValid(int value);
const plcStatus plcStatus_MIN = ePLCConnected;
const plcStatus plcStatus_MAX = ePLCUnknown;
const int plcStatus_ARRAYSIZE = plcStatus_MAX + 1;

const ::google::protobuf::EnumDescriptor* plcStatus_descriptor();
inline const ::std::string& plcStatus_Name(plcStatus value) {
  return ::google::protobuf::internal::NameOfEnum(
    plcStatus_descriptor(), value);
}
inline bool plcStatus_Parse(
    const ::std::string& name, plcStatus* value) {
  return ::google::protobuf::internal::ParseNamedEnum<plcStatus>(
    plcStatus_descriptor(), name, value);
}
enum logLevel {
  eSysInfo = 0,
  eSysLog = 1,
  eSysWarning = 2,
  eSysError = 3
};
bool logLevel_IsValid(int value);
const logLevel logLevel_MIN = eSysInfo;
const logLevel logLevel_MAX = eSysError;
const int logLevel_ARRAYSIZE = logLevel_MAX + 1;

const ::google::protobuf::EnumDescriptor* logLevel_descriptor();
inline const ::std::string& logLevel_Name(logLevel value) {
  return ::google::protobuf::internal::NameOfEnum(
    logLevel_descriptor(), value);
}
inline bool logLevel_Parse(
    const ::std::string& name, logLevel* value) {
  return ::google::protobuf::internal::ParseNamedEnum<logLevel>(
    logLevel_descriptor(), name, value);
}
// ===================================================================

class msg : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:globalmsg.msg) */ {
 public:
  msg();
  virtual ~msg();

  msg(const msg& from);

  inline msg& operator=(const msg& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  msg(msg&& from) noexcept
    : msg() {
    *this = ::std::move(from);
  }

  inline msg& operator=(msg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  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 PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    0;

  void Swap(msg* other);
  friend void swap(msg& a, msg& b) {
    a.Swap(&b);
  }

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

  inline msg* New() const PROTOBUF_FINAL { return New(NULL); }

  msg* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const msg& from);
  void MergeFrom(const msg& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(msg* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

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

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

  // optional .globalmsg.laserMsg laser_msg = 2;
  bool has_laser_msg() const;
  void clear_laser_msg();
  static const int kLaserMsgFieldNumber = 2;
  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);

  // optional .globalmsg.plcMsg plc_msg = 3;
  bool has_plc_msg() const;
  void clear_plc_msg();
  static const int kPlcMsgFieldNumber = 3;
  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);

  // optional .globalmsg.algMsg alg_msg = 4;
  bool has_alg_msg() const;
  void clear_alg_msg();
  static const int kAlgMsgFieldNumber = 4;
  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);

  // optional .globalmsg.SysMsg sys_msg = 5;
  bool has_sys_msg() const;
  void clear_sys_msg();
  static const int kSysMsgFieldNumber = 5;
  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);

  // required .globalmsg.type msg_type = 1;
  bool has_msg_type() const;
  void clear_msg_type();
  static const int kMsgTypeFieldNumber = 1;
  ::globalmsg::type msg_type() const;
  void set_msg_type(::globalmsg::type value);

  // @@protoc_insertion_point(class_scope:globalmsg.msg)
 private:
  void set_has_msg_type();
  void clear_has_msg_type();
  void set_has_laser_msg();
  void clear_has_laser_msg();
  void set_has_plc_msg();
  void clear_has_plc_msg();
  void set_has_alg_msg();
  void clear_has_alg_msg();
  void set_has_sys_msg();
  void clear_has_sys_msg();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::globalmsg::laserMsg* laser_msg_;
  ::globalmsg::plcMsg* plc_msg_;
  ::globalmsg::algMsg* alg_msg_;
  ::globalmsg::SysMsg* sys_msg_;
  int msg_type_;
  friend struct ::protobuf_globalmsg_2eproto::TableStruct;
  friend void ::protobuf_globalmsg_2eproto::InitDefaultsmsgImpl();
};
// -------------------------------------------------------------------

class laserMsg : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:globalmsg.laserMsg) */ {
 public:
  laserMsg();
  virtual ~laserMsg();

  laserMsg(const laserMsg& from);

  inline laserMsg& operator=(const laserMsg& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  laserMsg(laserMsg&& from) noexcept
    : laserMsg() {
    *this = ::std::move(from);
  }

  inline laserMsg& operator=(laserMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  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 PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    1;

  void Swap(laserMsg* other);
  friend void swap(laserMsg& a, laserMsg& b) {
    a.Swap(&b);
  }

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

  inline laserMsg* New() const PROTOBUF_FINAL { return New(NULL); }

  laserMsg* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const laserMsg& from);
  void MergeFrom(const laserMsg& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(laserMsg* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

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

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

  // optional .globalmsg.laserStatus laser_status = 1;
  bool has_laser_status() const;
  void clear_laser_status();
  static const int kLaserStatusFieldNumber = 1;
  ::globalmsg::laserStatus laser_status() const;
  void set_laser_status(::globalmsg::laserStatus value);

  // optional int32 queue_data_count = 2;
  bool has_queue_data_count() const;
  void clear_queue_data_count();
  static const int kQueueDataCountFieldNumber = 2;
  ::google::protobuf::int32 queue_data_count() const;
  void set_queue_data_count(::google::protobuf::int32 value);

  // optional int32 cloud_count = 3;
  bool has_cloud_count() const;
  void clear_cloud_count();
  static const int kCloudCountFieldNumber = 3;
  ::google::protobuf::int32 cloud_count() const;
  void set_cloud_count(::google::protobuf::int32 value);

  // required int32 id = 4;
  bool has_id() const;
  void clear_id();
  static const int kIdFieldNumber = 4;
  ::google::protobuf::int32 id() const;
  void set_id(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:globalmsg.laserMsg)
 private:
  void set_has_laser_status();
  void clear_has_laser_status();
  void set_has_queue_data_count();
  void clear_has_queue_data_count();
  void set_has_cloud_count();
  void clear_has_cloud_count();
  void set_has_id();
  void clear_has_id();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  int laser_status_;
  ::google::protobuf::int32 queue_data_count_;
  ::google::protobuf::int32 cloud_count_;
  ::google::protobuf::int32 id_;
  friend struct ::protobuf_globalmsg_2eproto::TableStruct;
  friend void ::protobuf_globalmsg_2eproto::InitDefaultslaserMsgImpl();
};
// -------------------------------------------------------------------

class plcMsg : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:globalmsg.plcMsg) */ {
 public:
  plcMsg();
  virtual ~plcMsg();

  plcMsg(const plcMsg& from);

  inline plcMsg& operator=(const plcMsg& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  plcMsg(plcMsg&& from) noexcept
    : plcMsg() {
    *this = ::std::move(from);
  }

  inline plcMsg& operator=(plcMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  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 PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    2;

  void Swap(plcMsg* other);
  friend void swap(plcMsg& a, plcMsg& b) {
    a.Swap(&b);
  }

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

  inline plcMsg* New() const PROTOBUF_FINAL { return New(NULL); }

  plcMsg* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const plcMsg& from);
  void MergeFrom(const plcMsg& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(plcMsg* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

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

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

  // repeated int32 plc_values = 2;
  int plc_values_size() const;
  void clear_plc_values();
  static const int kPlcValuesFieldNumber = 2;
  ::google::protobuf::int32 plc_values(int index) const;
  void set_plc_values(int index, ::google::protobuf::int32 value);
  void add_plc_values(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      plc_values() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_plc_values();

  // optional .globalmsg.plcStatus plc_status = 1;
  bool has_plc_status() const;
  void clear_plc_status();
  static const int kPlcStatusFieldNumber = 1;
  ::globalmsg::plcStatus plc_status() const;
  void set_plc_status(::globalmsg::plcStatus value);

  // @@protoc_insertion_point(class_scope:globalmsg.plcMsg)
 private:
  void set_has_plc_status();
  void clear_has_plc_status();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > plc_values_;
  int plc_status_;
  friend struct ::protobuf_globalmsg_2eproto::TableStruct;
  friend void ::protobuf_globalmsg_2eproto::InitDefaultsplcMsgImpl();
};
// -------------------------------------------------------------------

class resultInfo : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:globalmsg.resultInfo) */ {
 public:
  resultInfo();
  virtual ~resultInfo();

  resultInfo(const resultInfo& from);

  inline resultInfo& operator=(const resultInfo& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  resultInfo(resultInfo&& from) noexcept
    : resultInfo() {
    *this = ::std::move(from);
  }

  inline resultInfo& operator=(resultInfo&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  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 PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    3;

  void Swap(resultInfo* other);
  friend void swap(resultInfo& a, resultInfo& b) {
    a.Swap(&b);
  }

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

  inline resultInfo* New() const PROTOBUF_FINAL { return New(NULL); }

  resultInfo* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const resultInfo& from);
  void MergeFrom(const resultInfo& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(resultInfo* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

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

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

  // required string time = 1 [default = ""];
  bool has_time() const;
  void clear_time();
  static const int kTimeFieldNumber = 1;
  const ::std::string& time() const;
  void set_time(const ::std::string& value);
  #if LANG_CXX11
  void set_time(::std::string&& value);
  #endif
  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);

  // optional string error = 12 [default = ""];
  bool has_error() const;
  void clear_error();
  static const int kErrorFieldNumber = 12;
  const ::std::string& error() const;
  void set_error(const ::std::string& value);
  #if LANG_CXX11
  void set_error(::std::string&& value);
  #endif
  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);

  // required bool correctness = 2;
  bool has_correctness() const;
  void clear_correctness();
  static const int kCorrectnessFieldNumber = 2;
  bool correctness() const;
  void set_correctness(bool value);

  // optional int32 park_space_id = 3;
  bool has_park_space_id() const;
  void clear_park_space_id();
  static const int kParkSpaceIdFieldNumber = 3;
  ::google::protobuf::int32 park_space_id() const;
  void set_park_space_id(::google::protobuf::int32 value);

  // optional double x = 5;
  bool has_x() const;
  void clear_x();
  static const int kXFieldNumber = 5;
  double x() const;
  void set_x(double value);

  // optional double y = 6;
  bool has_y() const;
  void clear_y();
  static const int kYFieldNumber = 6;
  double y() const;
  void set_y(double value);

  // optional double c = 7;
  bool has_c() const;
  void clear_c();
  static const int kCFieldNumber = 7;
  double c() const;
  void set_c(double value);

  // optional double wheel_base = 8;
  bool has_wheel_base() const;
  void clear_wheel_base();
  static const int kWheelBaseFieldNumber = 8;
  double wheel_base() const;
  void set_wheel_base(double value);

  // optional double length = 9;
  bool has_length() const;
  void clear_length();
  static const int kLengthFieldNumber = 9;
  double length() const;
  void set_length(double value);

  // optional double width = 10;
  bool has_width() const;
  void clear_width();
  static const int kWidthFieldNumber = 10;
  double width() const;
  void set_width(double value);

  // optional double height = 11;
  bool has_height() const;
  void clear_height();
  static const int kHeightFieldNumber = 11;
  double height() const;
  void set_height(double value);

  // optional int32 laser_ids = 4;
  bool has_laser_ids() const;
  void clear_laser_ids();
  static const int kLaserIdsFieldNumber = 4;
  ::google::protobuf::int32 laser_ids() const;
  void set_laser_ids(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:globalmsg.resultInfo)
 private:
  void set_has_time();
  void clear_has_time();
  void set_has_correctness();
  void clear_has_correctness();
  void set_has_park_space_id();
  void clear_has_park_space_id();
  void set_has_laser_ids();
  void clear_has_laser_ids();
  void set_has_x();
  void clear_has_x();
  void set_has_y();
  void clear_has_y();
  void set_has_c();
  void clear_has_c();
  void set_has_wheel_base();
  void clear_has_wheel_base();
  void set_has_length();
  void clear_has_length();
  void set_has_width();
  void clear_has_width();
  void set_has_height();
  void clear_has_height();
  void set_has_error();
  void clear_has_error();

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

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr time_;
  ::google::protobuf::internal::ArenaStringPtr error_;
  bool correctness_;
  ::google::protobuf::int32 park_space_id_;
  double x_;
  double y_;
  double c_;
  double wheel_base_;
  double length_;
  double width_;
  double height_;
  ::google::protobuf::int32 laser_ids_;
  friend struct ::protobuf_globalmsg_2eproto::TableStruct;
  friend void ::protobuf_globalmsg_2eproto::InitDefaultsresultInfoImpl();
};
// -------------------------------------------------------------------

class algMsg : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:globalmsg.algMsg) */ {
 public:
  algMsg();
  virtual ~algMsg();

  algMsg(const algMsg& from);

  inline algMsg& operator=(const algMsg& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  algMsg(algMsg&& from) noexcept
    : algMsg() {
    *this = ::std::move(from);
  }

  inline algMsg& operator=(algMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  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 PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    4;

  void Swap(algMsg* other);
  friend void swap(algMsg& a, algMsg& b) {
    a.Swap(&b);
  }

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

  inline algMsg* New() const PROTOBUF_FINAL { return New(NULL); }

  algMsg* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const algMsg& from);
  void MergeFrom(const algMsg& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(algMsg* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

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

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

  // repeated .globalmsg.resultInfo result = 1;
  int result_size() const;
  void clear_result();
  static const int kResultFieldNumber = 1;
  const ::globalmsg::resultInfo& result(int index) const;
  ::globalmsg::resultInfo* mutable_result(int index);
  ::globalmsg::resultInfo* add_result();
  ::google::protobuf::RepeatedPtrField< ::globalmsg::resultInfo >*
      mutable_result();
  const ::google::protobuf::RepeatedPtrField< ::globalmsg::resultInfo >&
      result() const;

  // optional string log_path = 3 [default = ""];
  bool has_log_path() const;
  void clear_log_path();
  static const int kLogPathFieldNumber = 3;
  const ::std::string& log_path() const;
  void set_log_path(const ::std::string& value);
  #if LANG_CXX11
  void set_log_path(::std::string&& value);
  #endif
  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);

  // optional int32 thread_queue_size = 2;
  bool has_thread_queue_size() const;
  void clear_thread_queue_size();
  static const int kThreadQueueSizeFieldNumber = 2;
  ::google::protobuf::int32 thread_queue_size() const;
  void set_thread_queue_size(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:globalmsg.algMsg)
 private:
  void set_has_thread_queue_size();
  void clear_has_thread_queue_size();
  void set_has_log_path();
  void clear_has_log_path();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::globalmsg::resultInfo > result_;
  ::google::protobuf::internal::ArenaStringPtr log_path_;
  ::google::protobuf::int32 thread_queue_size_;
  friend struct ::protobuf_globalmsg_2eproto::TableStruct;
  friend void ::protobuf_globalmsg_2eproto::InitDefaultsalgMsgImpl();
};
// -------------------------------------------------------------------

class SysMsg : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:globalmsg.SysMsg) */ {
 public:
  SysMsg();
  virtual ~SysMsg();

  SysMsg(const SysMsg& from);

  inline SysMsg& operator=(const SysMsg& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SysMsg(SysMsg&& from) noexcept
    : SysMsg() {
    *this = ::std::move(from);
  }

  inline SysMsg& operator=(SysMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  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 PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    5;

  void Swap(SysMsg* other);
  friend void swap(SysMsg& a, SysMsg& b) {
    a.Swap(&b);
  }

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

  inline SysMsg* New() const PROTOBUF_FINAL { return New(NULL); }

  SysMsg* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const SysMsg& from);
  void MergeFrom(const SysMsg& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(SysMsg* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

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

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

  // required string log = 1 [default = ""];
  bool has_log() const;
  void clear_log();
  static const int kLogFieldNumber = 1;
  const ::std::string& log() const;
  void set_log(const ::std::string& value);
  #if LANG_CXX11
  void set_log(::std::string&& value);
  #endif
  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);

  // optional .globalmsg.logLevel level = 2 [default = eSysInfo];
  bool has_level() const;
  void clear_level();
  static const int kLevelFieldNumber = 2;
  ::globalmsg::logLevel level() const;
  void set_level(::globalmsg::logLevel value);

  // @@protoc_insertion_point(class_scope:globalmsg.SysMsg)
 private:
  void set_has_log();
  void clear_has_log();
  void set_has_level();
  void clear_has_level();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr log_;
  int level_;
  friend struct ::protobuf_globalmsg_2eproto::TableStruct;
  friend void ::protobuf_globalmsg_2eproto::InitDefaultsSysMsgImpl();
};
// ===================================================================


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

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

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

// optional .globalmsg.laserMsg laser_msg = 2;
inline bool msg::has_laser_msg() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void msg::set_has_laser_msg() {
  _has_bits_[0] |= 0x00000001u;
}
inline void msg::clear_has_laser_msg() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void msg::clear_laser_msg() {
  if (laser_msg_ != NULL) laser_msg_->Clear();
  clear_has_laser_msg();
}
inline const ::globalmsg::laserMsg& msg::laser_msg() const {
  const ::globalmsg::laserMsg* p = laser_msg_;
  // @@protoc_insertion_point(field_get:globalmsg.msg.laser_msg)
  return p != NULL ? *p : *reinterpret_cast<const ::globalmsg::laserMsg*>(
      &::globalmsg::_laserMsg_default_instance_);
}
inline ::globalmsg::laserMsg* msg::release_laser_msg() {
  // @@protoc_insertion_point(field_release:globalmsg.msg.laser_msg)
  clear_has_laser_msg();
  ::globalmsg::laserMsg* temp = laser_msg_;
  laser_msg_ = NULL;
  return temp;
}
inline ::globalmsg::laserMsg* msg::mutable_laser_msg() {
  set_has_laser_msg();
  if (laser_msg_ == NULL) {
    laser_msg_ = new ::globalmsg::laserMsg;
  }
  // @@protoc_insertion_point(field_mutable:globalmsg.msg.laser_msg)
  return laser_msg_;
}
inline void msg::set_allocated_laser_msg(::globalmsg::laserMsg* laser_msg) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete laser_msg_;
  }
  if (laser_msg) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      laser_msg = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, laser_msg, submessage_arena);
    }
    set_has_laser_msg();
  } else {
    clear_has_laser_msg();
  }
  laser_msg_ = laser_msg;
  // @@protoc_insertion_point(field_set_allocated:globalmsg.msg.laser_msg)
}

// optional .globalmsg.plcMsg plc_msg = 3;
inline bool msg::has_plc_msg() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void msg::set_has_plc_msg() {
  _has_bits_[0] |= 0x00000002u;
}
inline void msg::clear_has_plc_msg() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void msg::clear_plc_msg() {
  if (plc_msg_ != NULL) plc_msg_->Clear();
  clear_has_plc_msg();
}
inline const ::globalmsg::plcMsg& msg::plc_msg() const {
  const ::globalmsg::plcMsg* p = plc_msg_;
  // @@protoc_insertion_point(field_get:globalmsg.msg.plc_msg)
  return p != NULL ? *p : *reinterpret_cast<const ::globalmsg::plcMsg*>(
      &::globalmsg::_plcMsg_default_instance_);
}
inline ::globalmsg::plcMsg* msg::release_plc_msg() {
  // @@protoc_insertion_point(field_release:globalmsg.msg.plc_msg)
  clear_has_plc_msg();
  ::globalmsg::plcMsg* temp = plc_msg_;
  plc_msg_ = NULL;
  return temp;
}
inline ::globalmsg::plcMsg* msg::mutable_plc_msg() {
  set_has_plc_msg();
  if (plc_msg_ == NULL) {
    plc_msg_ = new ::globalmsg::plcMsg;
  }
  // @@protoc_insertion_point(field_mutable:globalmsg.msg.plc_msg)
  return plc_msg_;
}
inline void msg::set_allocated_plc_msg(::globalmsg::plcMsg* plc_msg) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete plc_msg_;
  }
  if (plc_msg) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      plc_msg = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, plc_msg, submessage_arena);
    }
    set_has_plc_msg();
  } else {
    clear_has_plc_msg();
  }
  plc_msg_ = plc_msg;
  // @@protoc_insertion_point(field_set_allocated:globalmsg.msg.plc_msg)
}

// optional .globalmsg.algMsg alg_msg = 4;
inline bool msg::has_alg_msg() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void msg::set_has_alg_msg() {
  _has_bits_[0] |= 0x00000004u;
}
inline void msg::clear_has_alg_msg() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void msg::clear_alg_msg() {
  if (alg_msg_ != NULL) alg_msg_->Clear();
  clear_has_alg_msg();
}
inline const ::globalmsg::algMsg& msg::alg_msg() const {
  const ::globalmsg::algMsg* p = alg_msg_;
  // @@protoc_insertion_point(field_get:globalmsg.msg.alg_msg)
  return p != NULL ? *p : *reinterpret_cast<const ::globalmsg::algMsg*>(
      &::globalmsg::_algMsg_default_instance_);
}
inline ::globalmsg::algMsg* msg::release_alg_msg() {
  // @@protoc_insertion_point(field_release:globalmsg.msg.alg_msg)
  clear_has_alg_msg();
  ::globalmsg::algMsg* temp = alg_msg_;
  alg_msg_ = NULL;
  return temp;
}
inline ::globalmsg::algMsg* msg::mutable_alg_msg() {
  set_has_alg_msg();
  if (alg_msg_ == NULL) {
    alg_msg_ = new ::globalmsg::algMsg;
  }
  // @@protoc_insertion_point(field_mutable:globalmsg.msg.alg_msg)
  return alg_msg_;
}
inline void msg::set_allocated_alg_msg(::globalmsg::algMsg* alg_msg) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete alg_msg_;
  }
  if (alg_msg) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      alg_msg = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, alg_msg, submessage_arena);
    }
    set_has_alg_msg();
  } else {
    clear_has_alg_msg();
  }
  alg_msg_ = alg_msg;
  // @@protoc_insertion_point(field_set_allocated:globalmsg.msg.alg_msg)
}

// optional .globalmsg.SysMsg sys_msg = 5;
inline bool msg::has_sys_msg() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void msg::set_has_sys_msg() {
  _has_bits_[0] |= 0x00000008u;
}
inline void msg::clear_has_sys_msg() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void msg::clear_sys_msg() {
  if (sys_msg_ != NULL) sys_msg_->Clear();
  clear_has_sys_msg();
}
inline const ::globalmsg::SysMsg& msg::sys_msg() const {
  const ::globalmsg::SysMsg* p = sys_msg_;
  // @@protoc_insertion_point(field_get:globalmsg.msg.sys_msg)
  return p != NULL ? *p : *reinterpret_cast<const ::globalmsg::SysMsg*>(
      &::globalmsg::_SysMsg_default_instance_);
}
inline ::globalmsg::SysMsg* msg::release_sys_msg() {
  // @@protoc_insertion_point(field_release:globalmsg.msg.sys_msg)
  clear_has_sys_msg();
  ::globalmsg::SysMsg* temp = sys_msg_;
  sys_msg_ = NULL;
  return temp;
}
inline ::globalmsg::SysMsg* msg::mutable_sys_msg() {
  set_has_sys_msg();
  if (sys_msg_ == NULL) {
    sys_msg_ = new ::globalmsg::SysMsg;
  }
  // @@protoc_insertion_point(field_mutable:globalmsg.msg.sys_msg)
  return sys_msg_;
}
inline void msg::set_allocated_sys_msg(::globalmsg::SysMsg* sys_msg) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete sys_msg_;
  }
  if (sys_msg) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      sys_msg = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, sys_msg, submessage_arena);
    }
    set_has_sys_msg();
  } else {
    clear_has_sys_msg();
  }
  sys_msg_ = sys_msg;
  // @@protoc_insertion_point(field_set_allocated:globalmsg.msg.sys_msg)
}

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

// laserMsg

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

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

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

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

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

// plcMsg

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

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

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

// resultInfo

// required string time = 1 [default = ""];
inline bool resultInfo::has_time() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void resultInfo::set_has_time() {
  _has_bits_[0] |= 0x00000001u;
}
inline void resultInfo::clear_has_time() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void resultInfo::clear_time() {
  time_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_time();
}
inline const ::std::string& resultInfo::time() const {
  // @@protoc_insertion_point(field_get:globalmsg.resultInfo.time)
  return time_.GetNoArena();
}
inline void resultInfo::set_time(const ::std::string& value) {
  set_has_time();
  time_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:globalmsg.resultInfo.time)
}
#if LANG_CXX11
inline void resultInfo::set_time(::std::string&& value) {
  set_has_time();
  time_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:globalmsg.resultInfo.time)
}
#endif
inline void resultInfo::set_time(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_time();
  time_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:globalmsg.resultInfo.time)
}
inline void resultInfo::set_time(const char* value, size_t size) {
  set_has_time();
  time_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:globalmsg.resultInfo.time)
}
inline ::std::string* resultInfo::mutable_time() {
  set_has_time();
  // @@protoc_insertion_point(field_mutable:globalmsg.resultInfo.time)
  return time_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* resultInfo::release_time() {
  // @@protoc_insertion_point(field_release:globalmsg.resultInfo.time)
  clear_has_time();
  return time_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void resultInfo::set_allocated_time(::std::string* time) {
  if (time != NULL) {
    set_has_time();
  } else {
    clear_has_time();
  }
  time_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), time);
  // @@protoc_insertion_point(field_set_allocated:globalmsg.resultInfo.time)
}

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

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

// optional int32 laser_ids = 4;
inline bool resultInfo::has_laser_ids() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void resultInfo::set_has_laser_ids() {
  _has_bits_[0] |= 0x00000800u;
}
inline void resultInfo::clear_has_laser_ids() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void resultInfo::clear_laser_ids() {
  laser_ids_ = 0;
  clear_has_laser_ids();
}
inline ::google::protobuf::int32 resultInfo::laser_ids() const {
  // @@protoc_insertion_point(field_get:globalmsg.resultInfo.laser_ids)
  return laser_ids_;
}
inline void resultInfo::set_laser_ids(::google::protobuf::int32 value) {
  set_has_laser_ids();
  laser_ids_ = value;
  // @@protoc_insertion_point(field_set:globalmsg.resultInfo.laser_ids)
}

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

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

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

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

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

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

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

// optional string error = 12 [default = ""];
inline bool resultInfo::has_error() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void resultInfo::set_has_error() {
  _has_bits_[0] |= 0x00000002u;
}
inline void resultInfo::clear_has_error() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void resultInfo::clear_error() {
  error_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_error();
}
inline const ::std::string& resultInfo::error() const {
  // @@protoc_insertion_point(field_get:globalmsg.resultInfo.error)
  return error_.GetNoArena();
}
inline void resultInfo::set_error(const ::std::string& value) {
  set_has_error();
  error_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:globalmsg.resultInfo.error)
}
#if LANG_CXX11
inline void resultInfo::set_error(::std::string&& value) {
  set_has_error();
  error_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:globalmsg.resultInfo.error)
}
#endif
inline void resultInfo::set_error(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_error();
  error_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:globalmsg.resultInfo.error)
}
inline void resultInfo::set_error(const char* value, size_t size) {
  set_has_error();
  error_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:globalmsg.resultInfo.error)
}
inline ::std::string* resultInfo::mutable_error() {
  set_has_error();
  // @@protoc_insertion_point(field_mutable:globalmsg.resultInfo.error)
  return error_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* resultInfo::release_error() {
  // @@protoc_insertion_point(field_release:globalmsg.resultInfo.error)
  clear_has_error();
  return error_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void resultInfo::set_allocated_error(::std::string* error) {
  if (error != NULL) {
    set_has_error();
  } else {
    clear_has_error();
  }
  error_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), error);
  // @@protoc_insertion_point(field_set_allocated:globalmsg.resultInfo.error)
}

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

// algMsg

// repeated .globalmsg.resultInfo result = 1;
inline int algMsg::result_size() const {
  return result_.size();
}
inline void algMsg::clear_result() {
  result_.Clear();
}
inline const ::globalmsg::resultInfo& algMsg::result(int index) const {
  // @@protoc_insertion_point(field_get:globalmsg.algMsg.result)
  return result_.Get(index);
}
inline ::globalmsg::resultInfo* algMsg::mutable_result(int index) {
  // @@protoc_insertion_point(field_mutable:globalmsg.algMsg.result)
  return result_.Mutable(index);
}
inline ::globalmsg::resultInfo* algMsg::add_result() {
  // @@protoc_insertion_point(field_add:globalmsg.algMsg.result)
  return result_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::globalmsg::resultInfo >*
algMsg::mutable_result() {
  // @@protoc_insertion_point(field_mutable_list:globalmsg.algMsg.result)
  return &result_;
}
inline const ::google::protobuf::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::has_thread_queue_size() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void algMsg::set_has_thread_queue_size() {
  _has_bits_[0] |= 0x00000002u;
}
inline void algMsg::clear_has_thread_queue_size() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void algMsg::clear_thread_queue_size() {
  thread_queue_size_ = 0;
  clear_has_thread_queue_size();
}
inline ::google::protobuf::int32 algMsg::thread_queue_size() const {
  // @@protoc_insertion_point(field_get:globalmsg.algMsg.thread_queue_size)
  return thread_queue_size_;
}
inline void algMsg::set_thread_queue_size(::google::protobuf::int32 value) {
  set_has_thread_queue_size();
  thread_queue_size_ = value;
  // @@protoc_insertion_point(field_set:globalmsg.algMsg.thread_queue_size)
}

// optional string log_path = 3 [default = ""];
inline bool algMsg::has_log_path() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void algMsg::set_has_log_path() {
  _has_bits_[0] |= 0x00000001u;
}
inline void algMsg::clear_has_log_path() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void algMsg::clear_log_path() {
  log_path_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_log_path();
}
inline const ::std::string& algMsg::log_path() const {
  // @@protoc_insertion_point(field_get:globalmsg.algMsg.log_path)
  return log_path_.GetNoArena();
}
inline void algMsg::set_log_path(const ::std::string& value) {
  set_has_log_path();
  log_path_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:globalmsg.algMsg.log_path)
}
#if LANG_CXX11
inline void algMsg::set_log_path(::std::string&& value) {
  set_has_log_path();
  log_path_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:globalmsg.algMsg.log_path)
}
#endif
inline void algMsg::set_log_path(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_log_path();
  log_path_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:globalmsg.algMsg.log_path)
}
inline void algMsg::set_log_path(const char* value, size_t size) {
  set_has_log_path();
  log_path_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:globalmsg.algMsg.log_path)
}
inline ::std::string* algMsg::mutable_log_path() {
  set_has_log_path();
  // @@protoc_insertion_point(field_mutable:globalmsg.algMsg.log_path)
  return log_path_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* algMsg::release_log_path() {
  // @@protoc_insertion_point(field_release:globalmsg.algMsg.log_path)
  clear_has_log_path();
  return log_path_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void algMsg::set_allocated_log_path(::std::string* log_path) {
  if (log_path != NULL) {
    set_has_log_path();
  } else {
    clear_has_log_path();
  }
  log_path_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), log_path);
  // @@protoc_insertion_point(field_set_allocated:globalmsg.algMsg.log_path)
}

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

// SysMsg

// required string log = 1 [default = ""];
inline bool SysMsg::has_log() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SysMsg::set_has_log() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SysMsg::clear_has_log() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SysMsg::clear_log() {
  log_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_log();
}
inline const ::std::string& SysMsg::log() const {
  // @@protoc_insertion_point(field_get:globalmsg.SysMsg.log)
  return log_.GetNoArena();
}
inline void SysMsg::set_log(const ::std::string& value) {
  set_has_log();
  log_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:globalmsg.SysMsg.log)
}
#if LANG_CXX11
inline void SysMsg::set_log(::std::string&& value) {
  set_has_log();
  log_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:globalmsg.SysMsg.log)
}
#endif
inline void SysMsg::set_log(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_log();
  log_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:globalmsg.SysMsg.log)
}
inline void SysMsg::set_log(const char* value, size_t size) {
  set_has_log();
  log_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:globalmsg.SysMsg.log)
}
inline ::std::string* SysMsg::mutable_log() {
  set_has_log();
  // @@protoc_insertion_point(field_mutable:globalmsg.SysMsg.log)
  return log_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SysMsg::release_log() {
  // @@protoc_insertion_point(field_release:globalmsg.SysMsg.log)
  clear_has_log();
  return log_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SysMsg::set_allocated_log(::std::string* log) {
  if (log != NULL) {
    set_has_log();
  } else {
    clear_has_log();
  }
  log_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), log);
  // @@protoc_insertion_point(field_set_allocated:globalmsg.SysMsg.log)
}

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

namespace google {
namespace protobuf {

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

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_globalmsg_2eproto__INCLUDED