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

#ifndef GOOGLE_PROTOBUF_INCLUDED_tracerMessage_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_tracerMessage_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#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 3021005 < 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_util.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/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_tracerMessage_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_tracerMessage_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tracerMessage_2eproto;
namespace autel {
namespace protocol {
class TracerStaggerFreqMessage;
struct TracerStaggerFreqMessageDefaultTypeInternal;
extern TracerStaggerFreqMessageDefaultTypeInternal _TracerStaggerFreqMessage_default_instance_;
class TracerSystemInfoMessage;
struct TracerSystemInfoMessageDefaultTypeInternal;
extern TracerSystemInfoMessageDefaultTypeInternal _TracerSystemInfoMessage_default_instance_;
class TracerWorkModeControlMessage;
struct TracerWorkModeControlMessageDefaultTypeInternal;
extern TracerWorkModeControlMessageDefaultTypeInternal _TracerWorkModeControlMessage_default_instance_;
class TracerWorkModeControlRspMessage;
struct TracerWorkModeControlRspMessageDefaultTypeInternal;
extern TracerWorkModeControlRspMessageDefaultTypeInternal _TracerWorkModeControlRspMessage_default_instance_;
class singleTargetInfo;
struct singleTargetInfoDefaultTypeInternal;
extern singleTargetInfoDefaultTypeInternal _singleTargetInfo_default_instance_;
class tracerMeasureInfoMessage;
struct tracerMeasureInfoMessageDefaultTypeInternal;
extern tracerMeasureInfoMessageDefaultTypeInternal _tracerMeasureInfoMessage_default_instance_;
}  // namespace protocol
}  // namespace autel
PROTOBUF_NAMESPACE_OPEN
template<> ::autel::protocol::TracerStaggerFreqMessage* Arena::CreateMaybeMessage<::autel::protocol::TracerStaggerFreqMessage>(Arena*);
template<> ::autel::protocol::TracerSystemInfoMessage* Arena::CreateMaybeMessage<::autel::protocol::TracerSystemInfoMessage>(Arena*);
template<> ::autel::protocol::TracerWorkModeControlMessage* Arena::CreateMaybeMessage<::autel::protocol::TracerWorkModeControlMessage>(Arena*);
template<> ::autel::protocol::TracerWorkModeControlRspMessage* Arena::CreateMaybeMessage<::autel::protocol::TracerWorkModeControlRspMessage>(Arena*);
template<> ::autel::protocol::singleTargetInfo* Arena::CreateMaybeMessage<::autel::protocol::singleTargetInfo>(Arena*);
template<> ::autel::protocol::tracerMeasureInfoMessage* Arena::CreateMaybeMessage<::autel::protocol::tracerMeasureInfoMessage>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace autel {
namespace protocol {

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

class singleTargetInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:autel.protocol.singleTargetInfo) */ {
 public:
  inline singleTargetInfo() : singleTargetInfo(nullptr) {}
  ~singleTargetInfo() override;
  explicit PROTOBUF_CONSTEXPR singleTargetInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline singleTargetInfo& operator=(const singleTargetInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline singleTargetInfo& operator=(singleTargetInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const singleTargetInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const singleTargetInfo* internal_default_instance() {
    return reinterpret_cast<const singleTargetInfo*>(
               &_singleTargetInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(singleTargetInfo& a, singleTargetInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(singleTargetInfo* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(singleTargetInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  singleTargetInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<singleTargetInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const singleTargetInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const singleTargetInfo& from) {
    singleTargetInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(singleTargetInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "autel.protocol.singleTargetInfo";
  }
  protected:
  explicit singleTargetInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kTNameFieldNumber = 17,
    kTNumFieldNumber = 1,
    kTTypeFieldNumber = 2,
    kTCalCntFieldNumber = 3,
    kTWorkStatusFieldNumber = 4,
    kTTimeCreateFieldNumber = 5,
    kTTimeTestFieldNumber = 6,
    kTSigBandFieldNumber = 7,
    kTDistanceFieldNumber = 8,
    kTFreqFieldNumber = 9,
    kTAmpFieldNumber = 10,
    kTmFwFieldNumber = 11,
    kTmFyFieldNumber = 12,
    kTfFwFieldNumber = 13,
    kTfFyFieldNumber = 14,
    kTConfidenceLevelFieldNumber = 15,
    kTTimeOffsetFieldNumber = 16,
  };
  // string tName = 17;
  void clear_tname();
  const std::string& tname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_tname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_tname();
  PROTOBUF_NODISCARD std::string* release_tname();
  void set_allocated_tname(std::string* tname);
  private:
  const std::string& _internal_tname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_tname(const std::string& value);
  std::string* _internal_mutable_tname();
  public:

  // uint32 tNum = 1;
  void clear_tnum();
  uint32_t tnum() const;
  void set_tnum(uint32_t value);
  private:
  uint32_t _internal_tnum() const;
  void _internal_set_tnum(uint32_t value);
  public:

  // uint32 tType = 2;
  void clear_ttype();
  uint32_t ttype() const;
  void set_ttype(uint32_t value);
  private:
  uint32_t _internal_ttype() const;
  void _internal_set_ttype(uint32_t value);
  public:

  // uint32 tCalCnt = 3;
  void clear_tcalcnt();
  uint32_t tcalcnt() const;
  void set_tcalcnt(uint32_t value);
  private:
  uint32_t _internal_tcalcnt() const;
  void _internal_set_tcalcnt(uint32_t value);
  public:

  // uint32 tWorkStatus = 4;
  void clear_tworkstatus();
  uint32_t tworkstatus() const;
  void set_tworkstatus(uint32_t value);
  private:
  uint32_t _internal_tworkstatus() const;
  void _internal_set_tworkstatus(uint32_t value);
  public:

  // uint32 tTimeCreate = 5;
  void clear_ttimecreate();
  uint32_t ttimecreate() const;
  void set_ttimecreate(uint32_t value);
  private:
  uint32_t _internal_ttimecreate() const;
  void _internal_set_ttimecreate(uint32_t value);
  public:

  // uint32 tTimeTest = 6;
  void clear_ttimetest();
  uint32_t ttimetest() const;
  void set_ttimetest(uint32_t value);
  private:
  uint32_t _internal_ttimetest() const;
  void _internal_set_ttimetest(uint32_t value);
  public:

  // uint32 tSigBand = 7;
  void clear_tsigband();
  uint32_t tsigband() const;
  void set_tsigband(uint32_t value);
  private:
  uint32_t _internal_tsigband() const;
  void _internal_set_tsigband(uint32_t value);
  public:

  // uint32 tDistance = 8;
  void clear_tdistance();
  uint32_t tdistance() const;
  void set_tdistance(uint32_t value);
  private:
  uint32_t _internal_tdistance() const;
  void _internal_set_tdistance(uint32_t value);
  public:

  // uint32 tFreq = 9;
  void clear_tfreq();
  uint32_t tfreq() const;
  void set_tfreq(uint32_t value);
  private:
  uint32_t _internal_tfreq() const;
  void _internal_set_tfreq(uint32_t value);
  public:

  // uint32 tAmp = 10;
  void clear_tamp();
  uint32_t tamp() const;
  void set_tamp(uint32_t value);
  private:
  uint32_t _internal_tamp() const;
  void _internal_set_tamp(uint32_t value);
  public:

  // sint32 tmFw = 11;
  void clear_tmfw();
  int32_t tmfw() const;
  void set_tmfw(int32_t value);
  private:
  int32_t _internal_tmfw() const;
  void _internal_set_tmfw(int32_t value);
  public:

  // sint32 tmFy = 12;
  void clear_tmfy();
  int32_t tmfy() const;
  void set_tmfy(int32_t value);
  private:
  int32_t _internal_tmfy() const;
  void _internal_set_tmfy(int32_t value);
  public:

  // sint32 tfFw = 13;
  void clear_tffw();
  int32_t tffw() const;
  void set_tffw(int32_t value);
  private:
  int32_t _internal_tffw() const;
  void _internal_set_tffw(int32_t value);
  public:

  // sint32 tfFy = 14;
  void clear_tffy();
  int32_t tffy() const;
  void set_tffy(int32_t value);
  private:
  int32_t _internal_tffy() const;
  void _internal_set_tffy(int32_t value);
  public:

  // uint32 tConfidenceLevel = 15;
  void clear_tconfidencelevel();
  uint32_t tconfidencelevel() const;
  void set_tconfidencelevel(uint32_t value);
  private:
  uint32_t _internal_tconfidencelevel() const;
  void _internal_set_tconfidencelevel(uint32_t value);
  public:

  // uint32 tTimeOffset = 16;
  void clear_ttimeoffset();
  uint32_t ttimeoffset() const;
  void set_ttimeoffset(uint32_t value);
  private:
  uint32_t _internal_ttimeoffset() const;
  void _internal_set_ttimeoffset(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:autel.protocol.singleTargetInfo)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tname_;
    uint32_t tnum_;
    uint32_t ttype_;
    uint32_t tcalcnt_;
    uint32_t tworkstatus_;
    uint32_t ttimecreate_;
    uint32_t ttimetest_;
    uint32_t tsigband_;
    uint32_t tdistance_;
    uint32_t tfreq_;
    uint32_t tamp_;
    int32_t tmfw_;
    int32_t tmfy_;
    int32_t tffw_;
    int32_t tffy_;
    uint32_t tconfidencelevel_;
    uint32_t ttimeoffset_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tracerMessage_2eproto;
};
// -------------------------------------------------------------------

class tracerMeasureInfoMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:autel.protocol.tracerMeasureInfoMessage) */ {
 public:
  inline tracerMeasureInfoMessage() : tracerMeasureInfoMessage(nullptr) {}
  ~tracerMeasureInfoMessage() override;
  explicit PROTOBUF_CONSTEXPR tracerMeasureInfoMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline tracerMeasureInfoMessage& operator=(const tracerMeasureInfoMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline tracerMeasureInfoMessage& operator=(tracerMeasureInfoMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const tracerMeasureInfoMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const tracerMeasureInfoMessage* internal_default_instance() {
    return reinterpret_cast<const tracerMeasureInfoMessage*>(
               &_tracerMeasureInfoMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(tracerMeasureInfoMessage& a, tracerMeasureInfoMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(tracerMeasureInfoMessage* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(tracerMeasureInfoMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  tracerMeasureInfoMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<tracerMeasureInfoMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const tracerMeasureInfoMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const tracerMeasureInfoMessage& from) {
    tracerMeasureInfoMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(tracerMeasureInfoMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "autel.protocol.tracerMeasureInfoMessage";
  }
  protected:
  explicit tracerMeasureInfoMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kTarInfoFieldNumber = 4,
    kFrameNumFieldNumber = 1,
    kWorkStatusFieldNumber = 2,
    kTarNumFieldNumber = 3,
    kWorkModeFieldNumber = 5,
  };
  // repeated .autel.protocol.singleTargetInfo tarInfo = 4;
  int tarinfo_size() const;
  private:
  int _internal_tarinfo_size() const;
  public:
  void clear_tarinfo();
  ::autel::protocol::singleTargetInfo* mutable_tarinfo(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::autel::protocol::singleTargetInfo >*
      mutable_tarinfo();
  private:
  const ::autel::protocol::singleTargetInfo& _internal_tarinfo(int index) const;
  ::autel::protocol::singleTargetInfo* _internal_add_tarinfo();
  public:
  const ::autel::protocol::singleTargetInfo& tarinfo(int index) const;
  ::autel::protocol::singleTargetInfo* add_tarinfo();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::autel::protocol::singleTargetInfo >&
      tarinfo() const;

  // uint32 frameNum = 1;
  void clear_framenum();
  uint32_t framenum() const;
  void set_framenum(uint32_t value);
  private:
  uint32_t _internal_framenum() const;
  void _internal_set_framenum(uint32_t value);
  public:

  // uint32 workStatus = 2;
  void clear_workstatus();
  uint32_t workstatus() const;
  void set_workstatus(uint32_t value);
  private:
  uint32_t _internal_workstatus() const;
  void _internal_set_workstatus(uint32_t value);
  public:

  // uint32 tarNum = 3;
  void clear_tarnum();
  uint32_t tarnum() const;
  void set_tarnum(uint32_t value);
  private:
  uint32_t _internal_tarnum() const;
  void _internal_set_tarnum(uint32_t value);
  public:

  // uint32 workMode = 5;
  void clear_workmode();
  uint32_t workmode() const;
  void set_workmode(uint32_t value);
  private:
  uint32_t _internal_workmode() const;
  void _internal_set_workmode(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:autel.protocol.tracerMeasureInfoMessage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::autel::protocol::singleTargetInfo > tarinfo_;
    uint32_t framenum_;
    uint32_t workstatus_;
    uint32_t tarnum_;
    uint32_t workmode_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tracerMessage_2eproto;
};
// -------------------------------------------------------------------

class TracerWorkModeControlMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:autel.protocol.TracerWorkModeControlMessage) */ {
 public:
  inline TracerWorkModeControlMessage() : TracerWorkModeControlMessage(nullptr) {}
  ~TracerWorkModeControlMessage() override;
  explicit PROTOBUF_CONSTEXPR TracerWorkModeControlMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline TracerWorkModeControlMessage& operator=(const TracerWorkModeControlMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline TracerWorkModeControlMessage& operator=(TracerWorkModeControlMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TracerWorkModeControlMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const TracerWorkModeControlMessage* internal_default_instance() {
    return reinterpret_cast<const TracerWorkModeControlMessage*>(
               &_TracerWorkModeControlMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(TracerWorkModeControlMessage& a, TracerWorkModeControlMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(TracerWorkModeControlMessage* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TracerWorkModeControlMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  TracerWorkModeControlMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TracerWorkModeControlMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TracerWorkModeControlMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const TracerWorkModeControlMessage& from) {
    TracerWorkModeControlMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TracerWorkModeControlMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "autel.protocol.TracerWorkModeControlMessage";
  }
  protected:
  explicit TracerWorkModeControlMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kSeqFieldNumber = 1,
    kWorkModeFieldNumber = 2,
    kDxNumFieldNumber = 3,
    kDxFreqFieldNumber = 4,
    kAirTypeFieldNumber = 5,
    kConfidenceThrFieldNumber = 6,
  };
  // uint32 seq = 1;
  void clear_seq();
  uint32_t seq() const;
  void set_seq(uint32_t value);
  private:
  uint32_t _internal_seq() const;
  void _internal_set_seq(uint32_t value);
  public:

  // uint32 workMode = 2;
  void clear_workmode();
  uint32_t workmode() const;
  void set_workmode(uint32_t value);
  private:
  uint32_t _internal_workmode() const;
  void _internal_set_workmode(uint32_t value);
  public:

  // uint32 dxNum = 3;
  void clear_dxnum();
  uint32_t dxnum() const;
  void set_dxnum(uint32_t value);
  private:
  uint32_t _internal_dxnum() const;
  void _internal_set_dxnum(uint32_t value);
  public:

  // uint32 dxFreq = 4;
  void clear_dxfreq();
  uint32_t dxfreq() const;
  void set_dxfreq(uint32_t value);
  private:
  uint32_t _internal_dxfreq() const;
  void _internal_set_dxfreq(uint32_t value);
  public:

  // uint32 airType = 5;
  void clear_airtype();
  uint32_t airtype() const;
  void set_airtype(uint32_t value);
  private:
  uint32_t _internal_airtype() const;
  void _internal_set_airtype(uint32_t value);
  public:

  // uint32 confidenceThr = 6;
  void clear_confidencethr();
  uint32_t confidencethr() const;
  void set_confidencethr(uint32_t value);
  private:
  uint32_t _internal_confidencethr() const;
  void _internal_set_confidencethr(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:autel.protocol.TracerWorkModeControlMessage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    uint32_t seq_;
    uint32_t workmode_;
    uint32_t dxnum_;
    uint32_t dxfreq_;
    uint32_t airtype_;
    uint32_t confidencethr_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tracerMessage_2eproto;
};
// -------------------------------------------------------------------

class TracerWorkModeControlRspMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:autel.protocol.TracerWorkModeControlRspMessage) */ {
 public:
  inline TracerWorkModeControlRspMessage() : TracerWorkModeControlRspMessage(nullptr) {}
  ~TracerWorkModeControlRspMessage() override;
  explicit PROTOBUF_CONSTEXPR TracerWorkModeControlRspMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline TracerWorkModeControlRspMessage& operator=(const TracerWorkModeControlRspMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline TracerWorkModeControlRspMessage& operator=(TracerWorkModeControlRspMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TracerWorkModeControlRspMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const TracerWorkModeControlRspMessage* internal_default_instance() {
    return reinterpret_cast<const TracerWorkModeControlRspMessage*>(
               &_TracerWorkModeControlRspMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(TracerWorkModeControlRspMessage& a, TracerWorkModeControlRspMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(TracerWorkModeControlRspMessage* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TracerWorkModeControlRspMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  TracerWorkModeControlRspMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TracerWorkModeControlRspMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TracerWorkModeControlRspMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const TracerWorkModeControlRspMessage& from) {
    TracerWorkModeControlRspMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TracerWorkModeControlRspMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "autel.protocol.TracerWorkModeControlRspMessage";
  }
  protected:
  explicit TracerWorkModeControlRspMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kSeqFieldNumber = 1,
    kRltFieldNumber = 2,
  };
  // uint32 seq = 1;
  void clear_seq();
  uint32_t seq() const;
  void set_seq(uint32_t value);
  private:
  uint32_t _internal_seq() const;
  void _internal_set_seq(uint32_t value);
  public:

  // uint32 rlt = 2;
  void clear_rlt();
  uint32_t rlt() const;
  void set_rlt(uint32_t value);
  private:
  uint32_t _internal_rlt() const;
  void _internal_set_rlt(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:autel.protocol.TracerWorkModeControlRspMessage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    uint32_t seq_;
    uint32_t rlt_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tracerMessage_2eproto;
};
// -------------------------------------------------------------------

class TracerStaggerFreqMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:autel.protocol.TracerStaggerFreqMessage) */ {
 public:
  inline TracerStaggerFreqMessage() : TracerStaggerFreqMessage(nullptr) {}
  ~TracerStaggerFreqMessage() override;
  explicit PROTOBUF_CONSTEXPR TracerStaggerFreqMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline TracerStaggerFreqMessage& operator=(const TracerStaggerFreqMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline TracerStaggerFreqMessage& operator=(TracerStaggerFreqMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TracerStaggerFreqMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const TracerStaggerFreqMessage* internal_default_instance() {
    return reinterpret_cast<const TracerStaggerFreqMessage*>(
               &_TracerStaggerFreqMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(TracerStaggerFreqMessage& a, TracerStaggerFreqMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(TracerStaggerFreqMessage* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TracerStaggerFreqMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  TracerStaggerFreqMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TracerStaggerFreqMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TracerStaggerFreqMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const TracerStaggerFreqMessage& from) {
    TracerStaggerFreqMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TracerStaggerFreqMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "autel.protocol.TracerStaggerFreqMessage";
  }
  protected:
  explicit TracerStaggerFreqMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kSeqFieldNumber = 1,
    kFreqBandFieldNumber = 2,
    kTimStampFieldNumber = 3,
    kReservFieldNumber = 4,
  };
  // uint32 seq = 1;
  void clear_seq();
  uint32_t seq() const;
  void set_seq(uint32_t value);
  private:
  uint32_t _internal_seq() const;
  void _internal_set_seq(uint32_t value);
  public:

  // uint32 freqBand = 2;
  void clear_freqband();
  uint32_t freqband() const;
  void set_freqband(uint32_t value);
  private:
  uint32_t _internal_freqband() const;
  void _internal_set_freqband(uint32_t value);
  public:

  // uint32 timStamp = 3;
  void clear_timstamp();
  uint32_t timstamp() const;
  void set_timstamp(uint32_t value);
  private:
  uint32_t _internal_timstamp() const;
  void _internal_set_timstamp(uint32_t value);
  public:

  // uint32 reserv = 4;
  void clear_reserv();
  uint32_t reserv() const;
  void set_reserv(uint32_t value);
  private:
  uint32_t _internal_reserv() const;
  void _internal_set_reserv(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:autel.protocol.TracerStaggerFreqMessage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    uint32_t seq_;
    uint32_t freqband_;
    uint32_t timstamp_;
    uint32_t reserv_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tracerMessage_2eproto;
};
// -------------------------------------------------------------------

class TracerSystemInfoMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:autel.protocol.TracerSystemInfoMessage) */ {
 public:
  inline TracerSystemInfoMessage() : TracerSystemInfoMessage(nullptr) {}
  ~TracerSystemInfoMessage() override;
  explicit PROTOBUF_CONSTEXPR TracerSystemInfoMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline TracerSystemInfoMessage& operator=(const TracerSystemInfoMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline TracerSystemInfoMessage& operator=(TracerSystemInfoMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TracerSystemInfoMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const TracerSystemInfoMessage* internal_default_instance() {
    return reinterpret_cast<const TracerSystemInfoMessage*>(
               &_TracerSystemInfoMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(TracerSystemInfoMessage& a, TracerSystemInfoMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(TracerSystemInfoMessage* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TracerSystemInfoMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  TracerSystemInfoMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TracerSystemInfoMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TracerSystemInfoMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const TracerSystemInfoMessage& from) {
    TracerSystemInfoMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  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;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TracerSystemInfoMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "autel.protocol.TracerSystemInfoMessage";
  }
  protected:
  explicit TracerSystemInfoMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kDiskFieldNumber = 11,
    kSnFieldNumber = 1,
    kVersionFieldNumber = 2,
    kSsidFieldNumber = 3,
    kIpAddressFieldNumber = 4,
    kWorkStatusFieldNumber = 5,
    kFaultStatusFieldNumber = 6,
    kNetStatusFieldNumber = 7,
    kUpTimeFieldNumber = 8,
    kCpuFieldNumber = 9,
    kMemoryFieldNumber = 10,
    kTemperatureFieldNumber = 12,
  };
  // repeated uint32 disk = 11;
  int disk_size() const;
  private:
  int _internal_disk_size() const;
  public:
  void clear_disk();
  private:
  uint32_t _internal_disk(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_disk() const;
  void _internal_add_disk(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_disk();
  public:
  uint32_t disk(int index) const;
  void set_disk(int index, uint32_t value);
  void add_disk(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      disk() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_disk();

  // string sn = 1;
  void clear_sn();
  const std::string& sn() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sn(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sn();
  PROTOBUF_NODISCARD std::string* release_sn();
  void set_allocated_sn(std::string* sn);
  private:
  const std::string& _internal_sn() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sn(const std::string& value);
  std::string* _internal_mutable_sn();
  public:

  // string version = 2;
  void clear_version();
  const std::string& version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_version();
  PROTOBUF_NODISCARD std::string* release_version();
  void set_allocated_version(std::string* version);
  private:
  const std::string& _internal_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
  std::string* _internal_mutable_version();
  public:

  // string ssid = 3;
  void clear_ssid();
  const std::string& ssid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_ssid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_ssid();
  PROTOBUF_NODISCARD std::string* release_ssid();
  void set_allocated_ssid(std::string* ssid);
  private:
  const std::string& _internal_ssid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ssid(const std::string& value);
  std::string* _internal_mutable_ssid();
  public:

  // string ipAddress = 4;
  void clear_ipaddress();
  const std::string& ipaddress() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_ipaddress(ArgT0&& arg0, ArgT... args);
  std::string* mutable_ipaddress();
  PROTOBUF_NODISCARD std::string* release_ipaddress();
  void set_allocated_ipaddress(std::string* ipaddress);
  private:
  const std::string& _internal_ipaddress() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ipaddress(const std::string& value);
  std::string* _internal_mutable_ipaddress();
  public:

  // uint32 workStatus = 5;
  void clear_workstatus();
  uint32_t workstatus() const;
  void set_workstatus(uint32_t value);
  private:
  uint32_t _internal_workstatus() const;
  void _internal_set_workstatus(uint32_t value);
  public:

  // uint32 faultStatus = 6;
  void clear_faultstatus();
  uint32_t faultstatus() const;
  void set_faultstatus(uint32_t value);
  private:
  uint32_t _internal_faultstatus() const;
  void _internal_set_faultstatus(uint32_t value);
  public:

  // uint32 netStatus = 7;
  void clear_netstatus();
  uint32_t netstatus() const;
  void set_netstatus(uint32_t value);
  private:
  uint32_t _internal_netstatus() const;
  void _internal_set_netstatus(uint32_t value);
  public:

  // uint32 upTime = 8;
  void clear_uptime();
  uint32_t uptime() const;
  void set_uptime(uint32_t value);
  private:
  uint32_t _internal_uptime() const;
  void _internal_set_uptime(uint32_t value);
  public:

  // uint32 cpu = 9;
  void clear_cpu();
  uint32_t cpu() const;
  void set_cpu(uint32_t value);
  private:
  uint32_t _internal_cpu() const;
  void _internal_set_cpu(uint32_t value);
  public:

  // uint32 memory = 10;
  void clear_memory();
  uint32_t memory() const;
  void set_memory(uint32_t value);
  private:
  uint32_t _internal_memory() const;
  void _internal_set_memory(uint32_t value);
  public:

  // uint32 temperature = 12;
  void clear_temperature();
  uint32_t temperature() const;
  void set_temperature(uint32_t value);
  private:
  uint32_t _internal_temperature() const;
  void _internal_set_temperature(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:autel.protocol.TracerSystemInfoMessage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > disk_;
    mutable std::atomic<int> _disk_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sn_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ssid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ipaddress_;
    uint32_t workstatus_;
    uint32_t faultstatus_;
    uint32_t netstatus_;
    uint32_t uptime_;
    uint32_t cpu_;
    uint32_t memory_;
    uint32_t temperature_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_tracerMessage_2eproto;
};
// ===================================================================


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

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

// uint32 tNum = 1;
inline void singleTargetInfo::clear_tnum() {
  _impl_.tnum_ = 0u;
}
inline uint32_t singleTargetInfo::_internal_tnum() const {
  return _impl_.tnum_;
}
inline uint32_t singleTargetInfo::tnum() const {
  // @@protoc_insertion_point(field_get:autel.protocol.singleTargetInfo.tNum)
  return _internal_tnum();
}
inline void singleTargetInfo::_internal_set_tnum(uint32_t value) {
  
  _impl_.tnum_ = value;
}
inline void singleTargetInfo::set_tnum(uint32_t value) {
  _internal_set_tnum(value);
  // @@protoc_insertion_point(field_set:autel.protocol.singleTargetInfo.tNum)
}

// uint32 tType = 2;
inline void singleTargetInfo::clear_ttype() {
  _impl_.ttype_ = 0u;
}
inline uint32_t singleTargetInfo::_internal_ttype() const {
  return _impl_.ttype_;
}
inline uint32_t singleTargetInfo::ttype() const {
  // @@protoc_insertion_point(field_get:autel.protocol.singleTargetInfo.tType)
  return _internal_ttype();
}
inline void singleTargetInfo::_internal_set_ttype(uint32_t value) {
  
  _impl_.ttype_ = value;
}
inline void singleTargetInfo::set_ttype(uint32_t value) {
  _internal_set_ttype(value);
  // @@protoc_insertion_point(field_set:autel.protocol.singleTargetInfo.tType)
}

// uint32 tCalCnt = 3;
inline void singleTargetInfo::clear_tcalcnt() {
  _impl_.tcalcnt_ = 0u;
}
inline uint32_t singleTargetInfo::_internal_tcalcnt() const {
  return _impl_.tcalcnt_;
}
inline uint32_t singleTargetInfo::tcalcnt() const {
  // @@protoc_insertion_point(field_get:autel.protocol.singleTargetInfo.tCalCnt)
  return _internal_tcalcnt();
}
inline void singleTargetInfo::_internal_set_tcalcnt(uint32_t value) {
  
  _impl_.tcalcnt_ = value;
}
inline void singleTargetInfo::set_tcalcnt(uint32_t value) {
  _internal_set_tcalcnt(value);
  // @@protoc_insertion_point(field_set:autel.protocol.singleTargetInfo.tCalCnt)
}

// uint32 tWorkStatus = 4;
inline void singleTargetInfo::clear_tworkstatus() {
  _impl_.tworkstatus_ = 0u;
}
inline uint32_t singleTargetInfo::_internal_tworkstatus() const {
  return _impl_.tworkstatus_;
}
inline uint32_t singleTargetInfo::tworkstatus() const {
  // @@protoc_insertion_point(field_get:autel.protocol.singleTargetInfo.tWorkStatus)
  return _internal_tworkstatus();
}
inline void singleTargetInfo::_internal_set_tworkstatus(uint32_t value) {
  
  _impl_.tworkstatus_ = value;
}
inline void singleTargetInfo::set_tworkstatus(uint32_t value) {
  _internal_set_tworkstatus(value);
  // @@protoc_insertion_point(field_set:autel.protocol.singleTargetInfo.tWorkStatus)
}

// uint32 tTimeCreate = 5;
inline void singleTargetInfo::clear_ttimecreate() {
  _impl_.ttimecreate_ = 0u;
}
inline uint32_t singleTargetInfo::_internal_ttimecreate() const {
  return _impl_.ttimecreate_;
}
inline uint32_t singleTargetInfo::ttimecreate() const {
  // @@protoc_insertion_point(field_get:autel.protocol.singleTargetInfo.tTimeCreate)
  return _internal_ttimecreate();
}
inline void singleTargetInfo::_internal_set_ttimecreate(uint32_t value) {
  
  _impl_.ttimecreate_ = value;
}
inline void singleTargetInfo::set_ttimecreate(uint32_t value) {
  _internal_set_ttimecreate(value);
  // @@protoc_insertion_point(field_set:autel.protocol.singleTargetInfo.tTimeCreate)
}

// uint32 tTimeTest = 6;
inline void singleTargetInfo::clear_ttimetest() {
  _impl_.ttimetest_ = 0u;
}
inline uint32_t singleTargetInfo::_internal_ttimetest() const {
  return _impl_.ttimetest_;
}
inline uint32_t singleTargetInfo::ttimetest() const {
  // @@protoc_insertion_point(field_get:autel.protocol.singleTargetInfo.tTimeTest)
  return _internal_ttimetest();
}
inline void singleTargetInfo::_internal_set_ttimetest(uint32_t value) {
  
  _impl_.ttimetest_ = value;
}
inline void singleTargetInfo::set_ttimetest(uint32_t value) {
  _internal_set_ttimetest(value);
  // @@protoc_insertion_point(field_set:autel.protocol.singleTargetInfo.tTimeTest)
}

// uint32 tSigBand = 7;
inline void singleTargetInfo::clear_tsigband() {
  _impl_.tsigband_ = 0u;
}
inline uint32_t singleTargetInfo::_internal_tsigband() const {
  return _impl_.tsigband_;
}
inline uint32_t singleTargetInfo::tsigband() const {
  // @@protoc_insertion_point(field_get:autel.protocol.singleTargetInfo.tSigBand)
  return _internal_tsigband();
}
inline void singleTargetInfo::_internal_set_tsigband(uint32_t value) {
  
  _impl_.tsigband_ = value;
}
inline void singleTargetInfo::set_tsigband(uint32_t value) {
  _internal_set_tsigband(value);
  // @@protoc_insertion_point(field_set:autel.protocol.singleTargetInfo.tSigBand)
}

// uint32 tDistance = 8;
inline void singleTargetInfo::clear_tdistance() {
  _impl_.tdistance_ = 0u;
}
inline uint32_t singleTargetInfo::_internal_tdistance() const {
  return _impl_.tdistance_;
}
inline uint32_t singleTargetInfo::tdistance() const {
  // @@protoc_insertion_point(field_get:autel.protocol.singleTargetInfo.tDistance)
  return _internal_tdistance();
}
inline void singleTargetInfo::_internal_set_tdistance(uint32_t value) {
  
  _impl_.tdistance_ = value;
}
inline void singleTargetInfo::set_tdistance(uint32_t value) {
  _internal_set_tdistance(value);
  // @@protoc_insertion_point(field_set:autel.protocol.singleTargetInfo.tDistance)
}

// uint32 tFreq = 9;
inline void singleTargetInfo::clear_tfreq() {
  _impl_.tfreq_ = 0u;
}
inline uint32_t singleTargetInfo::_internal_tfreq() const {
  return _impl_.tfreq_;
}
inline uint32_t singleTargetInfo::tfreq() const {
  // @@protoc_insertion_point(field_get:autel.protocol.singleTargetInfo.tFreq)
  return _internal_tfreq();
}
inline void singleTargetInfo::_internal_set_tfreq(uint32_t value) {
  
  _impl_.tfreq_ = value;
}
inline void singleTargetInfo::set_tfreq(uint32_t value) {
  _internal_set_tfreq(value);
  // @@protoc_insertion_point(field_set:autel.protocol.singleTargetInfo.tFreq)
}

// uint32 tAmp = 10;
inline void singleTargetInfo::clear_tamp() {
  _impl_.tamp_ = 0u;
}
inline uint32_t singleTargetInfo::_internal_tamp() const {
  return _impl_.tamp_;
}
inline uint32_t singleTargetInfo::tamp() const {
  // @@protoc_insertion_point(field_get:autel.protocol.singleTargetInfo.tAmp)
  return _internal_tamp();
}
inline void singleTargetInfo::_internal_set_tamp(uint32_t value) {
  
  _impl_.tamp_ = value;
}
inline void singleTargetInfo::set_tamp(uint32_t value) {
  _internal_set_tamp(value);
  // @@protoc_insertion_point(field_set:autel.protocol.singleTargetInfo.tAmp)
}

// sint32 tmFw = 11;
inline void singleTargetInfo::clear_tmfw() {
  _impl_.tmfw_ = 0;
}
inline int32_t singleTargetInfo::_internal_tmfw() const {
  return _impl_.tmfw_;
}
inline int32_t singleTargetInfo::tmfw() const {
  // @@protoc_insertion_point(field_get:autel.protocol.singleTargetInfo.tmFw)
  return _internal_tmfw();
}
inline void singleTargetInfo::_internal_set_tmfw(int32_t value) {
  
  _impl_.tmfw_ = value;
}
inline void singleTargetInfo::set_tmfw(int32_t value) {
  _internal_set_tmfw(value);
  // @@protoc_insertion_point(field_set:autel.protocol.singleTargetInfo.tmFw)
}

// sint32 tmFy = 12;
inline void singleTargetInfo::clear_tmfy() {
  _impl_.tmfy_ = 0;
}
inline int32_t singleTargetInfo::_internal_tmfy() const {
  return _impl_.tmfy_;
}
inline int32_t singleTargetInfo::tmfy() const {
  // @@protoc_insertion_point(field_get:autel.protocol.singleTargetInfo.tmFy)
  return _internal_tmfy();
}
inline void singleTargetInfo::_internal_set_tmfy(int32_t value) {
  
  _impl_.tmfy_ = value;
}
inline void singleTargetInfo::set_tmfy(int32_t value) {
  _internal_set_tmfy(value);
  // @@protoc_insertion_point(field_set:autel.protocol.singleTargetInfo.tmFy)
}

// sint32 tfFw = 13;
inline void singleTargetInfo::clear_tffw() {
  _impl_.tffw_ = 0;
}
inline int32_t singleTargetInfo::_internal_tffw() const {
  return _impl_.tffw_;
}
inline int32_t singleTargetInfo::tffw() const {
  // @@protoc_insertion_point(field_get:autel.protocol.singleTargetInfo.tfFw)
  return _internal_tffw();
}
inline void singleTargetInfo::_internal_set_tffw(int32_t value) {
  
  _impl_.tffw_ = value;
}
inline void singleTargetInfo::set_tffw(int32_t value) {
  _internal_set_tffw(value);
  // @@protoc_insertion_point(field_set:autel.protocol.singleTargetInfo.tfFw)
}

// sint32 tfFy = 14;
inline void singleTargetInfo::clear_tffy() {
  _impl_.tffy_ = 0;
}
inline int32_t singleTargetInfo::_internal_tffy() const {
  return _impl_.tffy_;
}
inline int32_t singleTargetInfo::tffy() const {
  // @@protoc_insertion_point(field_get:autel.protocol.singleTargetInfo.tfFy)
  return _internal_tffy();
}
inline void singleTargetInfo::_internal_set_tffy(int32_t value) {
  
  _impl_.tffy_ = value;
}
inline void singleTargetInfo::set_tffy(int32_t value) {
  _internal_set_tffy(value);
  // @@protoc_insertion_point(field_set:autel.protocol.singleTargetInfo.tfFy)
}

// uint32 tConfidenceLevel = 15;
inline void singleTargetInfo::clear_tconfidencelevel() {
  _impl_.tconfidencelevel_ = 0u;
}
inline uint32_t singleTargetInfo::_internal_tconfidencelevel() const {
  return _impl_.tconfidencelevel_;
}
inline uint32_t singleTargetInfo::tconfidencelevel() const {
  // @@protoc_insertion_point(field_get:autel.protocol.singleTargetInfo.tConfidenceLevel)
  return _internal_tconfidencelevel();
}
inline void singleTargetInfo::_internal_set_tconfidencelevel(uint32_t value) {
  
  _impl_.tconfidencelevel_ = value;
}
inline void singleTargetInfo::set_tconfidencelevel(uint32_t value) {
  _internal_set_tconfidencelevel(value);
  // @@protoc_insertion_point(field_set:autel.protocol.singleTargetInfo.tConfidenceLevel)
}

// uint32 tTimeOffset = 16;
inline void singleTargetInfo::clear_ttimeoffset() {
  _impl_.ttimeoffset_ = 0u;
}
inline uint32_t singleTargetInfo::_internal_ttimeoffset() const {
  return _impl_.ttimeoffset_;
}
inline uint32_t singleTargetInfo::ttimeoffset() const {
  // @@protoc_insertion_point(field_get:autel.protocol.singleTargetInfo.tTimeOffset)
  return _internal_ttimeoffset();
}
inline void singleTargetInfo::_internal_set_ttimeoffset(uint32_t value) {
  
  _impl_.ttimeoffset_ = value;
}
inline void singleTargetInfo::set_ttimeoffset(uint32_t value) {
  _internal_set_ttimeoffset(value);
  // @@protoc_insertion_point(field_set:autel.protocol.singleTargetInfo.tTimeOffset)
}

// string tName = 17;
inline void singleTargetInfo::clear_tname() {
  _impl_.tname_.ClearToEmpty();
}
inline const std::string& singleTargetInfo::tname() const {
  // @@protoc_insertion_point(field_get:autel.protocol.singleTargetInfo.tName)
  return _internal_tname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void singleTargetInfo::set_tname(ArgT0&& arg0, ArgT... args) {
 
 _impl_.tname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:autel.protocol.singleTargetInfo.tName)
}
inline std::string* singleTargetInfo::mutable_tname() {
  std::string* _s = _internal_mutable_tname();
  // @@protoc_insertion_point(field_mutable:autel.protocol.singleTargetInfo.tName)
  return _s;
}
inline const std::string& singleTargetInfo::_internal_tname() const {
  return _impl_.tname_.Get();
}
inline void singleTargetInfo::_internal_set_tname(const std::string& value) {
  
  _impl_.tname_.Set(value, GetArenaForAllocation());
}
inline std::string* singleTargetInfo::_internal_mutable_tname() {
  
  return _impl_.tname_.Mutable(GetArenaForAllocation());
}
inline std::string* singleTargetInfo::release_tname() {
  // @@protoc_insertion_point(field_release:autel.protocol.singleTargetInfo.tName)
  return _impl_.tname_.Release();
}
inline void singleTargetInfo::set_allocated_tname(std::string* tname) {
  if (tname != nullptr) {
    
  } else {
    
  }
  _impl_.tname_.SetAllocated(tname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.tname_.IsDefault()) {
    _impl_.tname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:autel.protocol.singleTargetInfo.tName)
}

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

// tracerMeasureInfoMessage

// uint32 frameNum = 1;
inline void tracerMeasureInfoMessage::clear_framenum() {
  _impl_.framenum_ = 0u;
}
inline uint32_t tracerMeasureInfoMessage::_internal_framenum() const {
  return _impl_.framenum_;
}
inline uint32_t tracerMeasureInfoMessage::framenum() const {
  // @@protoc_insertion_point(field_get:autel.protocol.tracerMeasureInfoMessage.frameNum)
  return _internal_framenum();
}
inline void tracerMeasureInfoMessage::_internal_set_framenum(uint32_t value) {
  
  _impl_.framenum_ = value;
}
inline void tracerMeasureInfoMessage::set_framenum(uint32_t value) {
  _internal_set_framenum(value);
  // @@protoc_insertion_point(field_set:autel.protocol.tracerMeasureInfoMessage.frameNum)
}

// uint32 workStatus = 2;
inline void tracerMeasureInfoMessage::clear_workstatus() {
  _impl_.workstatus_ = 0u;
}
inline uint32_t tracerMeasureInfoMessage::_internal_workstatus() const {
  return _impl_.workstatus_;
}
inline uint32_t tracerMeasureInfoMessage::workstatus() const {
  // @@protoc_insertion_point(field_get:autel.protocol.tracerMeasureInfoMessage.workStatus)
  return _internal_workstatus();
}
inline void tracerMeasureInfoMessage::_internal_set_workstatus(uint32_t value) {
  
  _impl_.workstatus_ = value;
}
inline void tracerMeasureInfoMessage::set_workstatus(uint32_t value) {
  _internal_set_workstatus(value);
  // @@protoc_insertion_point(field_set:autel.protocol.tracerMeasureInfoMessage.workStatus)
}

// uint32 tarNum = 3;
inline void tracerMeasureInfoMessage::clear_tarnum() {
  _impl_.tarnum_ = 0u;
}
inline uint32_t tracerMeasureInfoMessage::_internal_tarnum() const {
  return _impl_.tarnum_;
}
inline uint32_t tracerMeasureInfoMessage::tarnum() const {
  // @@protoc_insertion_point(field_get:autel.protocol.tracerMeasureInfoMessage.tarNum)
  return _internal_tarnum();
}
inline void tracerMeasureInfoMessage::_internal_set_tarnum(uint32_t value) {
  
  _impl_.tarnum_ = value;
}
inline void tracerMeasureInfoMessage::set_tarnum(uint32_t value) {
  _internal_set_tarnum(value);
  // @@protoc_insertion_point(field_set:autel.protocol.tracerMeasureInfoMessage.tarNum)
}

// repeated .autel.protocol.singleTargetInfo tarInfo = 4;
inline int tracerMeasureInfoMessage::_internal_tarinfo_size() const {
  return _impl_.tarinfo_.size();
}
inline int tracerMeasureInfoMessage::tarinfo_size() const {
  return _internal_tarinfo_size();
}
inline void tracerMeasureInfoMessage::clear_tarinfo() {
  _impl_.tarinfo_.Clear();
}
inline ::autel::protocol::singleTargetInfo* tracerMeasureInfoMessage::mutable_tarinfo(int index) {
  // @@protoc_insertion_point(field_mutable:autel.protocol.tracerMeasureInfoMessage.tarInfo)
  return _impl_.tarinfo_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::autel::protocol::singleTargetInfo >*
tracerMeasureInfoMessage::mutable_tarinfo() {
  // @@protoc_insertion_point(field_mutable_list:autel.protocol.tracerMeasureInfoMessage.tarInfo)
  return &_impl_.tarinfo_;
}
inline const ::autel::protocol::singleTargetInfo& tracerMeasureInfoMessage::_internal_tarinfo(int index) const {
  return _impl_.tarinfo_.Get(index);
}
inline const ::autel::protocol::singleTargetInfo& tracerMeasureInfoMessage::tarinfo(int index) const {
  // @@protoc_insertion_point(field_get:autel.protocol.tracerMeasureInfoMessage.tarInfo)
  return _internal_tarinfo(index);
}
inline ::autel::protocol::singleTargetInfo* tracerMeasureInfoMessage::_internal_add_tarinfo() {
  return _impl_.tarinfo_.Add();
}
inline ::autel::protocol::singleTargetInfo* tracerMeasureInfoMessage::add_tarinfo() {
  ::autel::protocol::singleTargetInfo* _add = _internal_add_tarinfo();
  // @@protoc_insertion_point(field_add:autel.protocol.tracerMeasureInfoMessage.tarInfo)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::autel::protocol::singleTargetInfo >&
tracerMeasureInfoMessage::tarinfo() const {
  // @@protoc_insertion_point(field_list:autel.protocol.tracerMeasureInfoMessage.tarInfo)
  return _impl_.tarinfo_;
}

// uint32 workMode = 5;
inline void tracerMeasureInfoMessage::clear_workmode() {
  _impl_.workmode_ = 0u;
}
inline uint32_t tracerMeasureInfoMessage::_internal_workmode() const {
  return _impl_.workmode_;
}
inline uint32_t tracerMeasureInfoMessage::workmode() const {
  // @@protoc_insertion_point(field_get:autel.protocol.tracerMeasureInfoMessage.workMode)
  return _internal_workmode();
}
inline void tracerMeasureInfoMessage::_internal_set_workmode(uint32_t value) {
  
  _impl_.workmode_ = value;
}
inline void tracerMeasureInfoMessage::set_workmode(uint32_t value) {
  _internal_set_workmode(value);
  // @@protoc_insertion_point(field_set:autel.protocol.tracerMeasureInfoMessage.workMode)
}

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

// TracerWorkModeControlMessage

// uint32 seq = 1;
inline void TracerWorkModeControlMessage::clear_seq() {
  _impl_.seq_ = 0u;
}
inline uint32_t TracerWorkModeControlMessage::_internal_seq() const {
  return _impl_.seq_;
}
inline uint32_t TracerWorkModeControlMessage::seq() const {
  // @@protoc_insertion_point(field_get:autel.protocol.TracerWorkModeControlMessage.seq)
  return _internal_seq();
}
inline void TracerWorkModeControlMessage::_internal_set_seq(uint32_t value) {
  
  _impl_.seq_ = value;
}
inline void TracerWorkModeControlMessage::set_seq(uint32_t value) {
  _internal_set_seq(value);
  // @@protoc_insertion_point(field_set:autel.protocol.TracerWorkModeControlMessage.seq)
}

// uint32 workMode = 2;
inline void TracerWorkModeControlMessage::clear_workmode() {
  _impl_.workmode_ = 0u;
}
inline uint32_t TracerWorkModeControlMessage::_internal_workmode() const {
  return _impl_.workmode_;
}
inline uint32_t TracerWorkModeControlMessage::workmode() const {
  // @@protoc_insertion_point(field_get:autel.protocol.TracerWorkModeControlMessage.workMode)
  return _internal_workmode();
}
inline void TracerWorkModeControlMessage::_internal_set_workmode(uint32_t value) {
  
  _impl_.workmode_ = value;
}
inline void TracerWorkModeControlMessage::set_workmode(uint32_t value) {
  _internal_set_workmode(value);
  // @@protoc_insertion_point(field_set:autel.protocol.TracerWorkModeControlMessage.workMode)
}

// uint32 dxNum = 3;
inline void TracerWorkModeControlMessage::clear_dxnum() {
  _impl_.dxnum_ = 0u;
}
inline uint32_t TracerWorkModeControlMessage::_internal_dxnum() const {
  return _impl_.dxnum_;
}
inline uint32_t TracerWorkModeControlMessage::dxnum() const {
  // @@protoc_insertion_point(field_get:autel.protocol.TracerWorkModeControlMessage.dxNum)
  return _internal_dxnum();
}
inline void TracerWorkModeControlMessage::_internal_set_dxnum(uint32_t value) {
  
  _impl_.dxnum_ = value;
}
inline void TracerWorkModeControlMessage::set_dxnum(uint32_t value) {
  _internal_set_dxnum(value);
  // @@protoc_insertion_point(field_set:autel.protocol.TracerWorkModeControlMessage.dxNum)
}

// uint32 dxFreq = 4;
inline void TracerWorkModeControlMessage::clear_dxfreq() {
  _impl_.dxfreq_ = 0u;
}
inline uint32_t TracerWorkModeControlMessage::_internal_dxfreq() const {
  return _impl_.dxfreq_;
}
inline uint32_t TracerWorkModeControlMessage::dxfreq() const {
  // @@protoc_insertion_point(field_get:autel.protocol.TracerWorkModeControlMessage.dxFreq)
  return _internal_dxfreq();
}
inline void TracerWorkModeControlMessage::_internal_set_dxfreq(uint32_t value) {
  
  _impl_.dxfreq_ = value;
}
inline void TracerWorkModeControlMessage::set_dxfreq(uint32_t value) {
  _internal_set_dxfreq(value);
  // @@protoc_insertion_point(field_set:autel.protocol.TracerWorkModeControlMessage.dxFreq)
}

// uint32 airType = 5;
inline void TracerWorkModeControlMessage::clear_airtype() {
  _impl_.airtype_ = 0u;
}
inline uint32_t TracerWorkModeControlMessage::_internal_airtype() const {
  return _impl_.airtype_;
}
inline uint32_t TracerWorkModeControlMessage::airtype() const {
  // @@protoc_insertion_point(field_get:autel.protocol.TracerWorkModeControlMessage.airType)
  return _internal_airtype();
}
inline void TracerWorkModeControlMessage::_internal_set_airtype(uint32_t value) {
  
  _impl_.airtype_ = value;
}
inline void TracerWorkModeControlMessage::set_airtype(uint32_t value) {
  _internal_set_airtype(value);
  // @@protoc_insertion_point(field_set:autel.protocol.TracerWorkModeControlMessage.airType)
}

// uint32 confidenceThr = 6;
inline void TracerWorkModeControlMessage::clear_confidencethr() {
  _impl_.confidencethr_ = 0u;
}
inline uint32_t TracerWorkModeControlMessage::_internal_confidencethr() const {
  return _impl_.confidencethr_;
}
inline uint32_t TracerWorkModeControlMessage::confidencethr() const {
  // @@protoc_insertion_point(field_get:autel.protocol.TracerWorkModeControlMessage.confidenceThr)
  return _internal_confidencethr();
}
inline void TracerWorkModeControlMessage::_internal_set_confidencethr(uint32_t value) {
  
  _impl_.confidencethr_ = value;
}
inline void TracerWorkModeControlMessage::set_confidencethr(uint32_t value) {
  _internal_set_confidencethr(value);
  // @@protoc_insertion_point(field_set:autel.protocol.TracerWorkModeControlMessage.confidenceThr)
}

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

// TracerWorkModeControlRspMessage

// uint32 seq = 1;
inline void TracerWorkModeControlRspMessage::clear_seq() {
  _impl_.seq_ = 0u;
}
inline uint32_t TracerWorkModeControlRspMessage::_internal_seq() const {
  return _impl_.seq_;
}
inline uint32_t TracerWorkModeControlRspMessage::seq() const {
  // @@protoc_insertion_point(field_get:autel.protocol.TracerWorkModeControlRspMessage.seq)
  return _internal_seq();
}
inline void TracerWorkModeControlRspMessage::_internal_set_seq(uint32_t value) {
  
  _impl_.seq_ = value;
}
inline void TracerWorkModeControlRspMessage::set_seq(uint32_t value) {
  _internal_set_seq(value);
  // @@protoc_insertion_point(field_set:autel.protocol.TracerWorkModeControlRspMessage.seq)
}

// uint32 rlt = 2;
inline void TracerWorkModeControlRspMessage::clear_rlt() {
  _impl_.rlt_ = 0u;
}
inline uint32_t TracerWorkModeControlRspMessage::_internal_rlt() const {
  return _impl_.rlt_;
}
inline uint32_t TracerWorkModeControlRspMessage::rlt() const {
  // @@protoc_insertion_point(field_get:autel.protocol.TracerWorkModeControlRspMessage.rlt)
  return _internal_rlt();
}
inline void TracerWorkModeControlRspMessage::_internal_set_rlt(uint32_t value) {
  
  _impl_.rlt_ = value;
}
inline void TracerWorkModeControlRspMessage::set_rlt(uint32_t value) {
  _internal_set_rlt(value);
  // @@protoc_insertion_point(field_set:autel.protocol.TracerWorkModeControlRspMessage.rlt)
}

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

// TracerStaggerFreqMessage

// uint32 seq = 1;
inline void TracerStaggerFreqMessage::clear_seq() {
  _impl_.seq_ = 0u;
}
inline uint32_t TracerStaggerFreqMessage::_internal_seq() const {
  return _impl_.seq_;
}
inline uint32_t TracerStaggerFreqMessage::seq() const {
  // @@protoc_insertion_point(field_get:autel.protocol.TracerStaggerFreqMessage.seq)
  return _internal_seq();
}
inline void TracerStaggerFreqMessage::_internal_set_seq(uint32_t value) {
  
  _impl_.seq_ = value;
}
inline void TracerStaggerFreqMessage::set_seq(uint32_t value) {
  _internal_set_seq(value);
  // @@protoc_insertion_point(field_set:autel.protocol.TracerStaggerFreqMessage.seq)
}

// uint32 freqBand = 2;
inline void TracerStaggerFreqMessage::clear_freqband() {
  _impl_.freqband_ = 0u;
}
inline uint32_t TracerStaggerFreqMessage::_internal_freqband() const {
  return _impl_.freqband_;
}
inline uint32_t TracerStaggerFreqMessage::freqband() const {
  // @@protoc_insertion_point(field_get:autel.protocol.TracerStaggerFreqMessage.freqBand)
  return _internal_freqband();
}
inline void TracerStaggerFreqMessage::_internal_set_freqband(uint32_t value) {
  
  _impl_.freqband_ = value;
}
inline void TracerStaggerFreqMessage::set_freqband(uint32_t value) {
  _internal_set_freqband(value);
  // @@protoc_insertion_point(field_set:autel.protocol.TracerStaggerFreqMessage.freqBand)
}

// uint32 timStamp = 3;
inline void TracerStaggerFreqMessage::clear_timstamp() {
  _impl_.timstamp_ = 0u;
}
inline uint32_t TracerStaggerFreqMessage::_internal_timstamp() const {
  return _impl_.timstamp_;
}
inline uint32_t TracerStaggerFreqMessage::timstamp() const {
  // @@protoc_insertion_point(field_get:autel.protocol.TracerStaggerFreqMessage.timStamp)
  return _internal_timstamp();
}
inline void TracerStaggerFreqMessage::_internal_set_timstamp(uint32_t value) {
  
  _impl_.timstamp_ = value;
}
inline void TracerStaggerFreqMessage::set_timstamp(uint32_t value) {
  _internal_set_timstamp(value);
  // @@protoc_insertion_point(field_set:autel.protocol.TracerStaggerFreqMessage.timStamp)
}

// uint32 reserv = 4;
inline void TracerStaggerFreqMessage::clear_reserv() {
  _impl_.reserv_ = 0u;
}
inline uint32_t TracerStaggerFreqMessage::_internal_reserv() const {
  return _impl_.reserv_;
}
inline uint32_t TracerStaggerFreqMessage::reserv() const {
  // @@protoc_insertion_point(field_get:autel.protocol.TracerStaggerFreqMessage.reserv)
  return _internal_reserv();
}
inline void TracerStaggerFreqMessage::_internal_set_reserv(uint32_t value) {
  
  _impl_.reserv_ = value;
}
inline void TracerStaggerFreqMessage::set_reserv(uint32_t value) {
  _internal_set_reserv(value);
  // @@protoc_insertion_point(field_set:autel.protocol.TracerStaggerFreqMessage.reserv)
}

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

// TracerSystemInfoMessage

// string sn = 1;
inline void TracerSystemInfoMessage::clear_sn() {
  _impl_.sn_.ClearToEmpty();
}
inline const std::string& TracerSystemInfoMessage::sn() const {
  // @@protoc_insertion_point(field_get:autel.protocol.TracerSystemInfoMessage.sn)
  return _internal_sn();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TracerSystemInfoMessage::set_sn(ArgT0&& arg0, ArgT... args) {
 
 _impl_.sn_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:autel.protocol.TracerSystemInfoMessage.sn)
}
inline std::string* TracerSystemInfoMessage::mutable_sn() {
  std::string* _s = _internal_mutable_sn();
  // @@protoc_insertion_point(field_mutable:autel.protocol.TracerSystemInfoMessage.sn)
  return _s;
}
inline const std::string& TracerSystemInfoMessage::_internal_sn() const {
  return _impl_.sn_.Get();
}
inline void TracerSystemInfoMessage::_internal_set_sn(const std::string& value) {
  
  _impl_.sn_.Set(value, GetArenaForAllocation());
}
inline std::string* TracerSystemInfoMessage::_internal_mutable_sn() {
  
  return _impl_.sn_.Mutable(GetArenaForAllocation());
}
inline std::string* TracerSystemInfoMessage::release_sn() {
  // @@protoc_insertion_point(field_release:autel.protocol.TracerSystemInfoMessage.sn)
  return _impl_.sn_.Release();
}
inline void TracerSystemInfoMessage::set_allocated_sn(std::string* sn) {
  if (sn != nullptr) {
    
  } else {
    
  }
  _impl_.sn_.SetAllocated(sn, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sn_.IsDefault()) {
    _impl_.sn_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:autel.protocol.TracerSystemInfoMessage.sn)
}

// string version = 2;
inline void TracerSystemInfoMessage::clear_version() {
  _impl_.version_.ClearToEmpty();
}
inline const std::string& TracerSystemInfoMessage::version() const {
  // @@protoc_insertion_point(field_get:autel.protocol.TracerSystemInfoMessage.version)
  return _internal_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TracerSystemInfoMessage::set_version(ArgT0&& arg0, ArgT... args) {
 
 _impl_.version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:autel.protocol.TracerSystemInfoMessage.version)
}
inline std::string* TracerSystemInfoMessage::mutable_version() {
  std::string* _s = _internal_mutable_version();
  // @@protoc_insertion_point(field_mutable:autel.protocol.TracerSystemInfoMessage.version)
  return _s;
}
inline const std::string& TracerSystemInfoMessage::_internal_version() const {
  return _impl_.version_.Get();
}
inline void TracerSystemInfoMessage::_internal_set_version(const std::string& value) {
  
  _impl_.version_.Set(value, GetArenaForAllocation());
}
inline std::string* TracerSystemInfoMessage::_internal_mutable_version() {
  
  return _impl_.version_.Mutable(GetArenaForAllocation());
}
inline std::string* TracerSystemInfoMessage::release_version() {
  // @@protoc_insertion_point(field_release:autel.protocol.TracerSystemInfoMessage.version)
  return _impl_.version_.Release();
}
inline void TracerSystemInfoMessage::set_allocated_version(std::string* version) {
  if (version != nullptr) {
    
  } else {
    
  }
  _impl_.version_.SetAllocated(version, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.version_.IsDefault()) {
    _impl_.version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:autel.protocol.TracerSystemInfoMessage.version)
}

// string ssid = 3;
inline void TracerSystemInfoMessage::clear_ssid() {
  _impl_.ssid_.ClearToEmpty();
}
inline const std::string& TracerSystemInfoMessage::ssid() const {
  // @@protoc_insertion_point(field_get:autel.protocol.TracerSystemInfoMessage.ssid)
  return _internal_ssid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TracerSystemInfoMessage::set_ssid(ArgT0&& arg0, ArgT... args) {
 
 _impl_.ssid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:autel.protocol.TracerSystemInfoMessage.ssid)
}
inline std::string* TracerSystemInfoMessage::mutable_ssid() {
  std::string* _s = _internal_mutable_ssid();
  // @@protoc_insertion_point(field_mutable:autel.protocol.TracerSystemInfoMessage.ssid)
  return _s;
}
inline const std::string& TracerSystemInfoMessage::_internal_ssid() const {
  return _impl_.ssid_.Get();
}
inline void TracerSystemInfoMessage::_internal_set_ssid(const std::string& value) {
  
  _impl_.ssid_.Set(value, GetArenaForAllocation());
}
inline std::string* TracerSystemInfoMessage::_internal_mutable_ssid() {
  
  return _impl_.ssid_.Mutable(GetArenaForAllocation());
}
inline std::string* TracerSystemInfoMessage::release_ssid() {
  // @@protoc_insertion_point(field_release:autel.protocol.TracerSystemInfoMessage.ssid)
  return _impl_.ssid_.Release();
}
inline void TracerSystemInfoMessage::set_allocated_ssid(std::string* ssid) {
  if (ssid != nullptr) {
    
  } else {
    
  }
  _impl_.ssid_.SetAllocated(ssid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.ssid_.IsDefault()) {
    _impl_.ssid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:autel.protocol.TracerSystemInfoMessage.ssid)
}

// string ipAddress = 4;
inline void TracerSystemInfoMessage::clear_ipaddress() {
  _impl_.ipaddress_.ClearToEmpty();
}
inline const std::string& TracerSystemInfoMessage::ipaddress() const {
  // @@protoc_insertion_point(field_get:autel.protocol.TracerSystemInfoMessage.ipAddress)
  return _internal_ipaddress();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TracerSystemInfoMessage::set_ipaddress(ArgT0&& arg0, ArgT... args) {
 
 _impl_.ipaddress_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:autel.protocol.TracerSystemInfoMessage.ipAddress)
}
inline std::string* TracerSystemInfoMessage::mutable_ipaddress() {
  std::string* _s = _internal_mutable_ipaddress();
  // @@protoc_insertion_point(field_mutable:autel.protocol.TracerSystemInfoMessage.ipAddress)
  return _s;
}
inline const std::string& TracerSystemInfoMessage::_internal_ipaddress() const {
  return _impl_.ipaddress_.Get();
}
inline void TracerSystemInfoMessage::_internal_set_ipaddress(const std::string& value) {
  
  _impl_.ipaddress_.Set(value, GetArenaForAllocation());
}
inline std::string* TracerSystemInfoMessage::_internal_mutable_ipaddress() {
  
  return _impl_.ipaddress_.Mutable(GetArenaForAllocation());
}
inline std::string* TracerSystemInfoMessage::release_ipaddress() {
  // @@protoc_insertion_point(field_release:autel.protocol.TracerSystemInfoMessage.ipAddress)
  return _impl_.ipaddress_.Release();
}
inline void TracerSystemInfoMessage::set_allocated_ipaddress(std::string* ipaddress) {
  if (ipaddress != nullptr) {
    
  } else {
    
  }
  _impl_.ipaddress_.SetAllocated(ipaddress, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.ipaddress_.IsDefault()) {
    _impl_.ipaddress_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:autel.protocol.TracerSystemInfoMessage.ipAddress)
}

// uint32 workStatus = 5;
inline void TracerSystemInfoMessage::clear_workstatus() {
  _impl_.workstatus_ = 0u;
}
inline uint32_t TracerSystemInfoMessage::_internal_workstatus() const {
  return _impl_.workstatus_;
}
inline uint32_t TracerSystemInfoMessage::workstatus() const {
  // @@protoc_insertion_point(field_get:autel.protocol.TracerSystemInfoMessage.workStatus)
  return _internal_workstatus();
}
inline void TracerSystemInfoMessage::_internal_set_workstatus(uint32_t value) {
  
  _impl_.workstatus_ = value;
}
inline void TracerSystemInfoMessage::set_workstatus(uint32_t value) {
  _internal_set_workstatus(value);
  // @@protoc_insertion_point(field_set:autel.protocol.TracerSystemInfoMessage.workStatus)
}

// uint32 faultStatus = 6;
inline void TracerSystemInfoMessage::clear_faultstatus() {
  _impl_.faultstatus_ = 0u;
}
inline uint32_t TracerSystemInfoMessage::_internal_faultstatus() const {
  return _impl_.faultstatus_;
}
inline uint32_t TracerSystemInfoMessage::faultstatus() const {
  // @@protoc_insertion_point(field_get:autel.protocol.TracerSystemInfoMessage.faultStatus)
  return _internal_faultstatus();
}
inline void TracerSystemInfoMessage::_internal_set_faultstatus(uint32_t value) {
  
  _impl_.faultstatus_ = value;
}
inline void TracerSystemInfoMessage::set_faultstatus(uint32_t value) {
  _internal_set_faultstatus(value);
  // @@protoc_insertion_point(field_set:autel.protocol.TracerSystemInfoMessage.faultStatus)
}

// uint32 netStatus = 7;
inline void TracerSystemInfoMessage::clear_netstatus() {
  _impl_.netstatus_ = 0u;
}
inline uint32_t TracerSystemInfoMessage::_internal_netstatus() const {
  return _impl_.netstatus_;
}
inline uint32_t TracerSystemInfoMessage::netstatus() const {
  // @@protoc_insertion_point(field_get:autel.protocol.TracerSystemInfoMessage.netStatus)
  return _internal_netstatus();
}
inline void TracerSystemInfoMessage::_internal_set_netstatus(uint32_t value) {
  
  _impl_.netstatus_ = value;
}
inline void TracerSystemInfoMessage::set_netstatus(uint32_t value) {
  _internal_set_netstatus(value);
  // @@protoc_insertion_point(field_set:autel.protocol.TracerSystemInfoMessage.netStatus)
}

// uint32 upTime = 8;
inline void TracerSystemInfoMessage::clear_uptime() {
  _impl_.uptime_ = 0u;
}
inline uint32_t TracerSystemInfoMessage::_internal_uptime() const {
  return _impl_.uptime_;
}
inline uint32_t TracerSystemInfoMessage::uptime() const {
  // @@protoc_insertion_point(field_get:autel.protocol.TracerSystemInfoMessage.upTime)
  return _internal_uptime();
}
inline void TracerSystemInfoMessage::_internal_set_uptime(uint32_t value) {
  
  _impl_.uptime_ = value;
}
inline void TracerSystemInfoMessage::set_uptime(uint32_t value) {
  _internal_set_uptime(value);
  // @@protoc_insertion_point(field_set:autel.protocol.TracerSystemInfoMessage.upTime)
}

// uint32 cpu = 9;
inline void TracerSystemInfoMessage::clear_cpu() {
  _impl_.cpu_ = 0u;
}
inline uint32_t TracerSystemInfoMessage::_internal_cpu() const {
  return _impl_.cpu_;
}
inline uint32_t TracerSystemInfoMessage::cpu() const {
  // @@protoc_insertion_point(field_get:autel.protocol.TracerSystemInfoMessage.cpu)
  return _internal_cpu();
}
inline void TracerSystemInfoMessage::_internal_set_cpu(uint32_t value) {
  
  _impl_.cpu_ = value;
}
inline void TracerSystemInfoMessage::set_cpu(uint32_t value) {
  _internal_set_cpu(value);
  // @@protoc_insertion_point(field_set:autel.protocol.TracerSystemInfoMessage.cpu)
}

// uint32 memory = 10;
inline void TracerSystemInfoMessage::clear_memory() {
  _impl_.memory_ = 0u;
}
inline uint32_t TracerSystemInfoMessage::_internal_memory() const {
  return _impl_.memory_;
}
inline uint32_t TracerSystemInfoMessage::memory() const {
  // @@protoc_insertion_point(field_get:autel.protocol.TracerSystemInfoMessage.memory)
  return _internal_memory();
}
inline void TracerSystemInfoMessage::_internal_set_memory(uint32_t value) {
  
  _impl_.memory_ = value;
}
inline void TracerSystemInfoMessage::set_memory(uint32_t value) {
  _internal_set_memory(value);
  // @@protoc_insertion_point(field_set:autel.protocol.TracerSystemInfoMessage.memory)
}

// repeated uint32 disk = 11;
inline int TracerSystemInfoMessage::_internal_disk_size() const {
  return _impl_.disk_.size();
}
inline int TracerSystemInfoMessage::disk_size() const {
  return _internal_disk_size();
}
inline void TracerSystemInfoMessage::clear_disk() {
  _impl_.disk_.Clear();
}
inline uint32_t TracerSystemInfoMessage::_internal_disk(int index) const {
  return _impl_.disk_.Get(index);
}
inline uint32_t TracerSystemInfoMessage::disk(int index) const {
  // @@protoc_insertion_point(field_get:autel.protocol.TracerSystemInfoMessage.disk)
  return _internal_disk(index);
}
inline void TracerSystemInfoMessage::set_disk(int index, uint32_t value) {
  _impl_.disk_.Set(index, value);
  // @@protoc_insertion_point(field_set:autel.protocol.TracerSystemInfoMessage.disk)
}
inline void TracerSystemInfoMessage::_internal_add_disk(uint32_t value) {
  _impl_.disk_.Add(value);
}
inline void TracerSystemInfoMessage::add_disk(uint32_t value) {
  _internal_add_disk(value);
  // @@protoc_insertion_point(field_add:autel.protocol.TracerSystemInfoMessage.disk)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
TracerSystemInfoMessage::_internal_disk() const {
  return _impl_.disk_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
TracerSystemInfoMessage::disk() const {
  // @@protoc_insertion_point(field_list:autel.protocol.TracerSystemInfoMessage.disk)
  return _internal_disk();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
TracerSystemInfoMessage::_internal_mutable_disk() {
  return &_impl_.disk_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
TracerSystemInfoMessage::mutable_disk() {
  // @@protoc_insertion_point(field_mutable_list:autel.protocol.TracerSystemInfoMessage.disk)
  return _internal_mutable_disk();
}

// uint32 temperature = 12;
inline void TracerSystemInfoMessage::clear_temperature() {
  _impl_.temperature_ = 0u;
}
inline uint32_t TracerSystemInfoMessage::_internal_temperature() const {
  return _impl_.temperature_;
}
inline uint32_t TracerSystemInfoMessage::temperature() const {
  // @@protoc_insertion_point(field_get:autel.protocol.TracerSystemInfoMessage.temperature)
  return _internal_temperature();
}
inline void TracerSystemInfoMessage::_internal_set_temperature(uint32_t value) {
  
  _impl_.temperature_ = value;
}
inline void TracerSystemInfoMessage::set_temperature(uint32_t value) {
  _internal_set_temperature(value);
  // @@protoc_insertion_point(field_set:autel.protocol.TracerSystemInfoMessage.temperature)
}

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace protocol
}  // namespace autel

// @@protoc_insertion_point(global_scope)

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