// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: mod-task-exec.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_mod_2dtask_2dexec_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_mod_2dtask_2dexec_2eproto

#include <limits>
#include <string>

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

// Internal implementation detail -- do not use these members.
struct TableStruct_mod_2dtask_2dexec_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_mod_2dtask_2dexec_2eproto;
class ReqTaskExecDetailSpec;
struct ReqTaskExecDetailSpecDefaultTypeInternal;
extern ReqTaskExecDetailSpecDefaultTypeInternal _ReqTaskExecDetailSpec_default_instance_;
class ReqTaskExecList;
struct ReqTaskExecListDefaultTypeInternal;
extern ReqTaskExecListDefaultTypeInternal _ReqTaskExecList_default_instance_;
class RetTaskExecDetailSpec;
struct RetTaskExecDetailSpecDefaultTypeInternal;
extern RetTaskExecDetailSpecDefaultTypeInternal _RetTaskExecDetailSpec_default_instance_;
class RetTaskExecElement;
struct RetTaskExecElementDefaultTypeInternal;
extern RetTaskExecElementDefaultTypeInternal _RetTaskExecElement_default_instance_;
PROTOBUF_NAMESPACE_OPEN
template<> ::ReqTaskExecDetailSpec* Arena::CreateMaybeMessage<::ReqTaskExecDetailSpec>(Arena*);
template<> ::ReqTaskExecList* Arena::CreateMaybeMessage<::ReqTaskExecList>(Arena*);
template<> ::RetTaskExecDetailSpec* Arena::CreateMaybeMessage<::RetTaskExecDetailSpec>(Arena*);
template<> ::RetTaskExecElement* Arena::CreateMaybeMessage<::RetTaskExecElement>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

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

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

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

  inline ReqTaskExecList& operator=(const ReqTaskExecList& from) {
    CopyFrom(from);
    return *this;
  }
  inline ReqTaskExecList& operator=(ReqTaskExecList&& 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 ReqTaskExecList& default_instance() {
    return *internal_default_instance();
  }
  static inline const ReqTaskExecList* internal_default_instance() {
    return reinterpret_cast<const ReqTaskExecList*>(
               &_ReqTaskExecList_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(ReqTaskExecList& a, ReqTaskExecList& b) {
    a.Swap(&b);
  }
  inline void Swap(ReqTaskExecList* 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(ReqTaskExecList* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ReqTaskExecList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ReqTaskExecList>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ReqTaskExecList& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ReqTaskExecList& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  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 _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReqTaskExecList* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ReqTaskExecList";
  }
  protected:
  explicit ReqTaskExecList(::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 {
    kCodeSearchFieldNumber = 1,
    kNoSearchFieldNumber = 2,
    kStartFieldNumber = 3,
    kEndFieldNumber = 4,
  };
  // string codeSearch = 1;
  void clear_codesearch();
  const std::string& codesearch() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_codesearch(ArgT0&& arg0, ArgT... args);
  std::string* mutable_codesearch();
  PROTOBUF_NODISCARD std::string* release_codesearch();
  void set_allocated_codesearch(std::string* codesearch);
  private:
  const std::string& _internal_codesearch() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_codesearch(const std::string& value);
  std::string* _internal_mutable_codesearch();
  public:

  // string noSearch = 2;
  void clear_nosearch();
  const std::string& nosearch() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_nosearch(ArgT0&& arg0, ArgT... args);
  std::string* mutable_nosearch();
  PROTOBUF_NODISCARD std::string* release_nosearch();
  void set_allocated_nosearch(std::string* nosearch);
  private:
  const std::string& _internal_nosearch() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_nosearch(const std::string& value);
  std::string* _internal_mutable_nosearch();
  public:

  // string start = 3;
  void clear_start();
  const std::string& start() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_start(ArgT0&& arg0, ArgT... args);
  std::string* mutable_start();
  PROTOBUF_NODISCARD std::string* release_start();
  void set_allocated_start(std::string* start);
  private:
  const std::string& _internal_start() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_start(const std::string& value);
  std::string* _internal_mutable_start();
  public:

  // string end = 4;
  void clear_end();
  const std::string& end() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_end(ArgT0&& arg0, ArgT... args);
  std::string* mutable_end();
  PROTOBUF_NODISCARD std::string* release_end();
  void set_allocated_end(std::string* end);
  private:
  const std::string& _internal_end() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_end(const std::string& value);
  std::string* _internal_mutable_end();
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr codesearch_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr nosearch_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr start_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr end_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2dtask_2dexec_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline RetTaskExecElement& operator=(const RetTaskExecElement& from) {
    CopyFrom(from);
    return *this;
  }
  inline RetTaskExecElement& operator=(RetTaskExecElement&& 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 RetTaskExecElement& default_instance() {
    return *internal_default_instance();
  }
  static inline const RetTaskExecElement* internal_default_instance() {
    return reinterpret_cast<const RetTaskExecElement*>(
               &_RetTaskExecElement_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(RetTaskExecElement& a, RetTaskExecElement& b) {
    a.Swap(&b);
  }
  inline void Swap(RetTaskExecElement* 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(RetTaskExecElement* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  RetTaskExecElement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RetTaskExecElement>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RetTaskExecElement& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const RetTaskExecElement& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  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 _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RetTaskExecElement* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "RetTaskExecElement";
  }
  protected:
  explicit RetTaskExecElement(::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 {
    kNoFieldNumber = 2,
    kSIdFieldNumber = 3,
    kSNoradFieldNumber = 4,
    kStartDtFieldNumber = 5,
    kEndDtFieldNumber = 6,
    kSiteNameFieldNumber = 8,
    kChannelFieldNumber = 9,
    kRadioFQFieldNumber = 10,
    kSignalBWFieldNumber = 11,
    kCarrierFQFieldNumber = 12,
    kModRateFieldNumber = 13,
    kModRecognitionFieldNumber = 14,
    kChirpRateFieldNumber = 15,
    kFmBWFieldNumber = 16,
    kSignalSysFieldNumber = 17,
    kCodingFieldNumber = 18,
    kElectricPotentialFieldNumber = 19,
    kSnrFieldNumber = 20,
    kFaultDeviceFieldNumber = 22,
    kFaultCodeFieldNumber = 23,
    kEchoFileNameFieldNumber = 24,
    kEchoFilePathFieldNumber = 26,
    kIdFieldNumber = 1,
    kSiteIdFieldNumber = 7,
    kSignalCheckFieldNumber = 21,
    kEchoFileSizeFieldNumber = 25,
  };
  // string no = 2;
  void clear_no();
  const std::string& no() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_no(ArgT0&& arg0, ArgT... args);
  std::string* mutable_no();
  PROTOBUF_NODISCARD std::string* release_no();
  void set_allocated_no(std::string* no);
  private:
  const std::string& _internal_no() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_no(const std::string& value);
  std::string* _internal_mutable_no();
  public:

  // string sId = 3;
  void clear_sid();
  const std::string& sid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sid();
  PROTOBUF_NODISCARD std::string* release_sid();
  void set_allocated_sid(std::string* sid);
  private:
  const std::string& _internal_sid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sid(const std::string& value);
  std::string* _internal_mutable_sid();
  public:

  // string sNorad = 4;
  void clear_snorad();
  const std::string& snorad() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_snorad(ArgT0&& arg0, ArgT... args);
  std::string* mutable_snorad();
  PROTOBUF_NODISCARD std::string* release_snorad();
  void set_allocated_snorad(std::string* snorad);
  private:
  const std::string& _internal_snorad() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_snorad(const std::string& value);
  std::string* _internal_mutable_snorad();
  public:

  // string startDt = 5;
  void clear_startdt();
  const std::string& startdt() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_startdt(ArgT0&& arg0, ArgT... args);
  std::string* mutable_startdt();
  PROTOBUF_NODISCARD std::string* release_startdt();
  void set_allocated_startdt(std::string* startdt);
  private:
  const std::string& _internal_startdt() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_startdt(const std::string& value);
  std::string* _internal_mutable_startdt();
  public:

  // string endDt = 6;
  void clear_enddt();
  const std::string& enddt() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_enddt(ArgT0&& arg0, ArgT... args);
  std::string* mutable_enddt();
  PROTOBUF_NODISCARD std::string* release_enddt();
  void set_allocated_enddt(std::string* enddt);
  private:
  const std::string& _internal_enddt() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_enddt(const std::string& value);
  std::string* _internal_mutable_enddt();
  public:

  // string siteName = 8;
  void clear_sitename();
  const std::string& sitename() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sitename(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sitename();
  PROTOBUF_NODISCARD std::string* release_sitename();
  void set_allocated_sitename(std::string* sitename);
  private:
  const std::string& _internal_sitename() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sitename(const std::string& value);
  std::string* _internal_mutable_sitename();
  public:

  // string channel = 9;
  void clear_channel();
  const std::string& channel() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_channel(ArgT0&& arg0, ArgT... args);
  std::string* mutable_channel();
  PROTOBUF_NODISCARD std::string* release_channel();
  void set_allocated_channel(std::string* channel);
  private:
  const std::string& _internal_channel() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_channel(const std::string& value);
  std::string* _internal_mutable_channel();
  public:

  // string radioFQ = 10;
  void clear_radiofq();
  const std::string& radiofq() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_radiofq(ArgT0&& arg0, ArgT... args);
  std::string* mutable_radiofq();
  PROTOBUF_NODISCARD std::string* release_radiofq();
  void set_allocated_radiofq(std::string* radiofq);
  private:
  const std::string& _internal_radiofq() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_radiofq(const std::string& value);
  std::string* _internal_mutable_radiofq();
  public:

  // string signalBW = 11;
  void clear_signalbw();
  const std::string& signalbw() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_signalbw(ArgT0&& arg0, ArgT... args);
  std::string* mutable_signalbw();
  PROTOBUF_NODISCARD std::string* release_signalbw();
  void set_allocated_signalbw(std::string* signalbw);
  private:
  const std::string& _internal_signalbw() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signalbw(const std::string& value);
  std::string* _internal_mutable_signalbw();
  public:

  // string carrierFQ = 12;
  void clear_carrierfq();
  const std::string& carrierfq() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_carrierfq(ArgT0&& arg0, ArgT... args);
  std::string* mutable_carrierfq();
  PROTOBUF_NODISCARD std::string* release_carrierfq();
  void set_allocated_carrierfq(std::string* carrierfq);
  private:
  const std::string& _internal_carrierfq() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_carrierfq(const std::string& value);
  std::string* _internal_mutable_carrierfq();
  public:

  // string modRate = 13;
  void clear_modrate();
  const std::string& modrate() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_modrate(ArgT0&& arg0, ArgT... args);
  std::string* mutable_modrate();
  PROTOBUF_NODISCARD std::string* release_modrate();
  void set_allocated_modrate(std::string* modrate);
  private:
  const std::string& _internal_modrate() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_modrate(const std::string& value);
  std::string* _internal_mutable_modrate();
  public:

  // string modRecognition = 14;
  void clear_modrecognition();
  const std::string& modrecognition() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_modrecognition(ArgT0&& arg0, ArgT... args);
  std::string* mutable_modrecognition();
  PROTOBUF_NODISCARD std::string* release_modrecognition();
  void set_allocated_modrecognition(std::string* modrecognition);
  private:
  const std::string& _internal_modrecognition() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_modrecognition(const std::string& value);
  std::string* _internal_mutable_modrecognition();
  public:

  // string chirpRate = 15;
  void clear_chirprate();
  const std::string& chirprate() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_chirprate(ArgT0&& arg0, ArgT... args);
  std::string* mutable_chirprate();
  PROTOBUF_NODISCARD std::string* release_chirprate();
  void set_allocated_chirprate(std::string* chirprate);
  private:
  const std::string& _internal_chirprate() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_chirprate(const std::string& value);
  std::string* _internal_mutable_chirprate();
  public:

  // string fmBW = 16;
  void clear_fmbw();
  const std::string& fmbw() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fmbw(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fmbw();
  PROTOBUF_NODISCARD std::string* release_fmbw();
  void set_allocated_fmbw(std::string* fmbw);
  private:
  const std::string& _internal_fmbw() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fmbw(const std::string& value);
  std::string* _internal_mutable_fmbw();
  public:

  // string signalSys = 17;
  void clear_signalsys();
  const std::string& signalsys() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_signalsys(ArgT0&& arg0, ArgT... args);
  std::string* mutable_signalsys();
  PROTOBUF_NODISCARD std::string* release_signalsys();
  void set_allocated_signalsys(std::string* signalsys);
  private:
  const std::string& _internal_signalsys() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signalsys(const std::string& value);
  std::string* _internal_mutable_signalsys();
  public:

  // string coding = 18;
  void clear_coding();
  const std::string& coding() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_coding(ArgT0&& arg0, ArgT... args);
  std::string* mutable_coding();
  PROTOBUF_NODISCARD std::string* release_coding();
  void set_allocated_coding(std::string* coding);
  private:
  const std::string& _internal_coding() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_coding(const std::string& value);
  std::string* _internal_mutable_coding();
  public:

  // string electricPotential = 19;
  void clear_electricpotential();
  const std::string& electricpotential() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_electricpotential(ArgT0&& arg0, ArgT... args);
  std::string* mutable_electricpotential();
  PROTOBUF_NODISCARD std::string* release_electricpotential();
  void set_allocated_electricpotential(std::string* electricpotential);
  private:
  const std::string& _internal_electricpotential() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_electricpotential(const std::string& value);
  std::string* _internal_mutable_electricpotential();
  public:

  // string snr = 20;
  void clear_snr();
  const std::string& snr() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_snr(ArgT0&& arg0, ArgT... args);
  std::string* mutable_snr();
  PROTOBUF_NODISCARD std::string* release_snr();
  void set_allocated_snr(std::string* snr);
  private:
  const std::string& _internal_snr() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_snr(const std::string& value);
  std::string* _internal_mutable_snr();
  public:

  // string faultDevice = 22;
  void clear_faultdevice();
  const std::string& faultdevice() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_faultdevice(ArgT0&& arg0, ArgT... args);
  std::string* mutable_faultdevice();
  PROTOBUF_NODISCARD std::string* release_faultdevice();
  void set_allocated_faultdevice(std::string* faultdevice);
  private:
  const std::string& _internal_faultdevice() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_faultdevice(const std::string& value);
  std::string* _internal_mutable_faultdevice();
  public:

  // string faultCode = 23;
  void clear_faultcode();
  const std::string& faultcode() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_faultcode(ArgT0&& arg0, ArgT... args);
  std::string* mutable_faultcode();
  PROTOBUF_NODISCARD std::string* release_faultcode();
  void set_allocated_faultcode(std::string* faultcode);
  private:
  const std::string& _internal_faultcode() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_faultcode(const std::string& value);
  std::string* _internal_mutable_faultcode();
  public:

  // string echoFileName = 24;
  void clear_echofilename();
  const std::string& echofilename() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_echofilename(ArgT0&& arg0, ArgT... args);
  std::string* mutable_echofilename();
  PROTOBUF_NODISCARD std::string* release_echofilename();
  void set_allocated_echofilename(std::string* echofilename);
  private:
  const std::string& _internal_echofilename() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_echofilename(const std::string& value);
  std::string* _internal_mutable_echofilename();
  public:

  // string echoFilePath = 26;
  void clear_echofilepath();
  const std::string& echofilepath() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_echofilepath(ArgT0&& arg0, ArgT... args);
  std::string* mutable_echofilepath();
  PROTOBUF_NODISCARD std::string* release_echofilepath();
  void set_allocated_echofilepath(std::string* echofilepath);
  private:
  const std::string& _internal_echofilepath() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_echofilepath(const std::string& value);
  std::string* _internal_mutable_echofilepath();
  public:

  // int32 id = 1;
  void clear_id();
  int32_t id() const;
  void set_id(int32_t value);
  private:
  int32_t _internal_id() const;
  void _internal_set_id(int32_t value);
  public:

  // int32 siteId = 7;
  void clear_siteid();
  int32_t siteid() const;
  void set_siteid(int32_t value);
  private:
  int32_t _internal_siteid() const;
  void _internal_set_siteid(int32_t value);
  public:

  // bool signalCheck = 21;
  void clear_signalcheck();
  bool signalcheck() const;
  void set_signalcheck(bool value);
  private:
  bool _internal_signalcheck() const;
  void _internal_set_signalcheck(bool value);
  public:

  // int32 echoFileSize = 25;
  void clear_echofilesize();
  int32_t echofilesize() const;
  void set_echofilesize(int32_t value);
  private:
  int32_t _internal_echofilesize() const;
  void _internal_set_echofilesize(int32_t value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr no_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr snorad_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr startdt_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr enddt_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sitename_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr channel_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr radiofq_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signalbw_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr carrierfq_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr modrate_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr modrecognition_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr chirprate_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fmbw_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signalsys_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr coding_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr electricpotential_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr snr_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr faultdevice_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr faultcode_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr echofilename_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr echofilepath_;
  int32_t id_;
  int32_t siteid_;
  bool signalcheck_;
  int32_t echofilesize_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2dtask_2dexec_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ReqTaskExecDetailSpec& operator=(const ReqTaskExecDetailSpec& from) {
    CopyFrom(from);
    return *this;
  }
  inline ReqTaskExecDetailSpec& operator=(ReqTaskExecDetailSpec&& 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 ReqTaskExecDetailSpec& default_instance() {
    return *internal_default_instance();
  }
  static inline const ReqTaskExecDetailSpec* internal_default_instance() {
    return reinterpret_cast<const ReqTaskExecDetailSpec*>(
               &_ReqTaskExecDetailSpec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(ReqTaskExecDetailSpec& a, ReqTaskExecDetailSpec& b) {
    a.Swap(&b);
  }
  inline void Swap(ReqTaskExecDetailSpec* 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(ReqTaskExecDetailSpec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ReqTaskExecDetailSpec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ReqTaskExecDetailSpec>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ReqTaskExecDetailSpec& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ReqTaskExecDetailSpec& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  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 _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReqTaskExecDetailSpec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ReqTaskExecDetailSpec";
  }
  protected:
  explicit ReqTaskExecDetailSpec(::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 {
    kIdFieldNumber = 1,
  };
  // int32 id = 1;
  void clear_id();
  int32_t id() const;
  void set_id(int32_t value);
  private:
  int32_t _internal_id() const;
  void _internal_set_id(int32_t value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  int32_t id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2dtask_2dexec_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline RetTaskExecDetailSpec& operator=(const RetTaskExecDetailSpec& from) {
    CopyFrom(from);
    return *this;
  }
  inline RetTaskExecDetailSpec& operator=(RetTaskExecDetailSpec&& 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 RetTaskExecDetailSpec& default_instance() {
    return *internal_default_instance();
  }
  static inline const RetTaskExecDetailSpec* internal_default_instance() {
    return reinterpret_cast<const RetTaskExecDetailSpec*>(
               &_RetTaskExecDetailSpec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(RetTaskExecDetailSpec& a, RetTaskExecDetailSpec& b) {
    a.Swap(&b);
  }
  inline void Swap(RetTaskExecDetailSpec* 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(RetTaskExecDetailSpec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  RetTaskExecDetailSpec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RetTaskExecDetailSpec>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RetTaskExecDetailSpec& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const RetTaskExecDetailSpec& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  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 _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RetTaskExecDetailSpec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "RetTaskExecDetailSpec";
  }
  protected:
  explicit RetTaskExecDetailSpec(::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 {
    kFreqFieldNumber = 1,
    kDbmFieldNumber = 2,
  };
  // int32 freq = 1;
  void clear_freq();
  int32_t freq() const;
  void set_freq(int32_t value);
  private:
  int32_t _internal_freq() const;
  void _internal_set_freq(int32_t value);
  public:

  // int32 dbm = 2;
  void clear_dbm();
  int32_t dbm() const;
  void set_dbm(int32_t value);
  private:
  int32_t _internal_dbm() const;
  void _internal_set_dbm(int32_t value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  int32_t freq_;
  int32_t dbm_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2dtask_2dexec_2eproto;
};
// ===================================================================


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

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

// string codeSearch = 1;
inline void ReqTaskExecList::clear_codesearch() {
  codesearch_.ClearToEmpty();
}
inline const std::string& ReqTaskExecList::codesearch() const {
  // @@protoc_insertion_point(field_get:ReqTaskExecList.codeSearch)
  return _internal_codesearch();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqTaskExecList::set_codesearch(ArgT0&& arg0, ArgT... args) {
 
 codesearch_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqTaskExecList.codeSearch)
}
inline std::string* ReqTaskExecList::mutable_codesearch() {
  std::string* _s = _internal_mutable_codesearch();
  // @@protoc_insertion_point(field_mutable:ReqTaskExecList.codeSearch)
  return _s;
}
inline const std::string& ReqTaskExecList::_internal_codesearch() const {
  return codesearch_.Get();
}
inline void ReqTaskExecList::_internal_set_codesearch(const std::string& value) {
  
  codesearch_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqTaskExecList::_internal_mutable_codesearch() {
  
  return codesearch_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqTaskExecList::release_codesearch() {
  // @@protoc_insertion_point(field_release:ReqTaskExecList.codeSearch)
  return codesearch_.Release();
}
inline void ReqTaskExecList::set_allocated_codesearch(std::string* codesearch) {
  if (codesearch != nullptr) {
    
  } else {
    
  }
  codesearch_.SetAllocated(codesearch, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (codesearch_.IsDefault()) {
    codesearch_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqTaskExecList.codeSearch)
}

// string noSearch = 2;
inline void ReqTaskExecList::clear_nosearch() {
  nosearch_.ClearToEmpty();
}
inline const std::string& ReqTaskExecList::nosearch() const {
  // @@protoc_insertion_point(field_get:ReqTaskExecList.noSearch)
  return _internal_nosearch();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqTaskExecList::set_nosearch(ArgT0&& arg0, ArgT... args) {
 
 nosearch_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqTaskExecList.noSearch)
}
inline std::string* ReqTaskExecList::mutable_nosearch() {
  std::string* _s = _internal_mutable_nosearch();
  // @@protoc_insertion_point(field_mutable:ReqTaskExecList.noSearch)
  return _s;
}
inline const std::string& ReqTaskExecList::_internal_nosearch() const {
  return nosearch_.Get();
}
inline void ReqTaskExecList::_internal_set_nosearch(const std::string& value) {
  
  nosearch_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqTaskExecList::_internal_mutable_nosearch() {
  
  return nosearch_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqTaskExecList::release_nosearch() {
  // @@protoc_insertion_point(field_release:ReqTaskExecList.noSearch)
  return nosearch_.Release();
}
inline void ReqTaskExecList::set_allocated_nosearch(std::string* nosearch) {
  if (nosearch != nullptr) {
    
  } else {
    
  }
  nosearch_.SetAllocated(nosearch, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (nosearch_.IsDefault()) {
    nosearch_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqTaskExecList.noSearch)
}

// string start = 3;
inline void ReqTaskExecList::clear_start() {
  start_.ClearToEmpty();
}
inline const std::string& ReqTaskExecList::start() const {
  // @@protoc_insertion_point(field_get:ReqTaskExecList.start)
  return _internal_start();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqTaskExecList::set_start(ArgT0&& arg0, ArgT... args) {
 
 start_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqTaskExecList.start)
}
inline std::string* ReqTaskExecList::mutable_start() {
  std::string* _s = _internal_mutable_start();
  // @@protoc_insertion_point(field_mutable:ReqTaskExecList.start)
  return _s;
}
inline const std::string& ReqTaskExecList::_internal_start() const {
  return start_.Get();
}
inline void ReqTaskExecList::_internal_set_start(const std::string& value) {
  
  start_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqTaskExecList::_internal_mutable_start() {
  
  return start_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqTaskExecList::release_start() {
  // @@protoc_insertion_point(field_release:ReqTaskExecList.start)
  return start_.Release();
}
inline void ReqTaskExecList::set_allocated_start(std::string* start) {
  if (start != nullptr) {
    
  } else {
    
  }
  start_.SetAllocated(start, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (start_.IsDefault()) {
    start_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqTaskExecList.start)
}

// string end = 4;
inline void ReqTaskExecList::clear_end() {
  end_.ClearToEmpty();
}
inline const std::string& ReqTaskExecList::end() const {
  // @@protoc_insertion_point(field_get:ReqTaskExecList.end)
  return _internal_end();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqTaskExecList::set_end(ArgT0&& arg0, ArgT... args) {
 
 end_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqTaskExecList.end)
}
inline std::string* ReqTaskExecList::mutable_end() {
  std::string* _s = _internal_mutable_end();
  // @@protoc_insertion_point(field_mutable:ReqTaskExecList.end)
  return _s;
}
inline const std::string& ReqTaskExecList::_internal_end() const {
  return end_.Get();
}
inline void ReqTaskExecList::_internal_set_end(const std::string& value) {
  
  end_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqTaskExecList::_internal_mutable_end() {
  
  return end_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqTaskExecList::release_end() {
  // @@protoc_insertion_point(field_release:ReqTaskExecList.end)
  return end_.Release();
}
inline void ReqTaskExecList::set_allocated_end(std::string* end) {
  if (end != nullptr) {
    
  } else {
    
  }
  end_.SetAllocated(end, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (end_.IsDefault()) {
    end_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqTaskExecList.end)
}

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

// RetTaskExecElement

// int32 id = 1;
inline void RetTaskExecElement::clear_id() {
  id_ = 0;
}
inline int32_t RetTaskExecElement::_internal_id() const {
  return id_;
}
inline int32_t RetTaskExecElement::id() const {
  // @@protoc_insertion_point(field_get:RetTaskExecElement.id)
  return _internal_id();
}
inline void RetTaskExecElement::_internal_set_id(int32_t value) {
  
  id_ = value;
}
inline void RetTaskExecElement::set_id(int32_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:RetTaskExecElement.id)
}

// string no = 2;
inline void RetTaskExecElement::clear_no() {
  no_.ClearToEmpty();
}
inline const std::string& RetTaskExecElement::no() const {
  // @@protoc_insertion_point(field_get:RetTaskExecElement.no)
  return _internal_no();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskExecElement::set_no(ArgT0&& arg0, ArgT... args) {
 
 no_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetTaskExecElement.no)
}
inline std::string* RetTaskExecElement::mutable_no() {
  std::string* _s = _internal_mutable_no();
  // @@protoc_insertion_point(field_mutable:RetTaskExecElement.no)
  return _s;
}
inline const std::string& RetTaskExecElement::_internal_no() const {
  return no_.Get();
}
inline void RetTaskExecElement::_internal_set_no(const std::string& value) {
  
  no_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::_internal_mutable_no() {
  
  return no_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::release_no() {
  // @@protoc_insertion_point(field_release:RetTaskExecElement.no)
  return no_.Release();
}
inline void RetTaskExecElement::set_allocated_no(std::string* no) {
  if (no != nullptr) {
    
  } else {
    
  }
  no_.SetAllocated(no, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (no_.IsDefault()) {
    no_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetTaskExecElement.no)
}

// string sId = 3;
inline void RetTaskExecElement::clear_sid() {
  sid_.ClearToEmpty();
}
inline const std::string& RetTaskExecElement::sid() const {
  // @@protoc_insertion_point(field_get:RetTaskExecElement.sId)
  return _internal_sid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskExecElement::set_sid(ArgT0&& arg0, ArgT... args) {
 
 sid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetTaskExecElement.sId)
}
inline std::string* RetTaskExecElement::mutable_sid() {
  std::string* _s = _internal_mutable_sid();
  // @@protoc_insertion_point(field_mutable:RetTaskExecElement.sId)
  return _s;
}
inline const std::string& RetTaskExecElement::_internal_sid() const {
  return sid_.Get();
}
inline void RetTaskExecElement::_internal_set_sid(const std::string& value) {
  
  sid_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::_internal_mutable_sid() {
  
  return sid_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::release_sid() {
  // @@protoc_insertion_point(field_release:RetTaskExecElement.sId)
  return sid_.Release();
}
inline void RetTaskExecElement::set_allocated_sid(std::string* sid) {
  if (sid != nullptr) {
    
  } else {
    
  }
  sid_.SetAllocated(sid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (sid_.IsDefault()) {
    sid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetTaskExecElement.sId)
}

// string sNorad = 4;
inline void RetTaskExecElement::clear_snorad() {
  snorad_.ClearToEmpty();
}
inline const std::string& RetTaskExecElement::snorad() const {
  // @@protoc_insertion_point(field_get:RetTaskExecElement.sNorad)
  return _internal_snorad();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskExecElement::set_snorad(ArgT0&& arg0, ArgT... args) {
 
 snorad_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetTaskExecElement.sNorad)
}
inline std::string* RetTaskExecElement::mutable_snorad() {
  std::string* _s = _internal_mutable_snorad();
  // @@protoc_insertion_point(field_mutable:RetTaskExecElement.sNorad)
  return _s;
}
inline const std::string& RetTaskExecElement::_internal_snorad() const {
  return snorad_.Get();
}
inline void RetTaskExecElement::_internal_set_snorad(const std::string& value) {
  
  snorad_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::_internal_mutable_snorad() {
  
  return snorad_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::release_snorad() {
  // @@protoc_insertion_point(field_release:RetTaskExecElement.sNorad)
  return snorad_.Release();
}
inline void RetTaskExecElement::set_allocated_snorad(std::string* snorad) {
  if (snorad != nullptr) {
    
  } else {
    
  }
  snorad_.SetAllocated(snorad, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (snorad_.IsDefault()) {
    snorad_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetTaskExecElement.sNorad)
}

// string startDt = 5;
inline void RetTaskExecElement::clear_startdt() {
  startdt_.ClearToEmpty();
}
inline const std::string& RetTaskExecElement::startdt() const {
  // @@protoc_insertion_point(field_get:RetTaskExecElement.startDt)
  return _internal_startdt();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskExecElement::set_startdt(ArgT0&& arg0, ArgT... args) {
 
 startdt_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetTaskExecElement.startDt)
}
inline std::string* RetTaskExecElement::mutable_startdt() {
  std::string* _s = _internal_mutable_startdt();
  // @@protoc_insertion_point(field_mutable:RetTaskExecElement.startDt)
  return _s;
}
inline const std::string& RetTaskExecElement::_internal_startdt() const {
  return startdt_.Get();
}
inline void RetTaskExecElement::_internal_set_startdt(const std::string& value) {
  
  startdt_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::_internal_mutable_startdt() {
  
  return startdt_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::release_startdt() {
  // @@protoc_insertion_point(field_release:RetTaskExecElement.startDt)
  return startdt_.Release();
}
inline void RetTaskExecElement::set_allocated_startdt(std::string* startdt) {
  if (startdt != nullptr) {
    
  } else {
    
  }
  startdt_.SetAllocated(startdt, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (startdt_.IsDefault()) {
    startdt_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetTaskExecElement.startDt)
}

// string endDt = 6;
inline void RetTaskExecElement::clear_enddt() {
  enddt_.ClearToEmpty();
}
inline const std::string& RetTaskExecElement::enddt() const {
  // @@protoc_insertion_point(field_get:RetTaskExecElement.endDt)
  return _internal_enddt();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskExecElement::set_enddt(ArgT0&& arg0, ArgT... args) {
 
 enddt_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetTaskExecElement.endDt)
}
inline std::string* RetTaskExecElement::mutable_enddt() {
  std::string* _s = _internal_mutable_enddt();
  // @@protoc_insertion_point(field_mutable:RetTaskExecElement.endDt)
  return _s;
}
inline const std::string& RetTaskExecElement::_internal_enddt() const {
  return enddt_.Get();
}
inline void RetTaskExecElement::_internal_set_enddt(const std::string& value) {
  
  enddt_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::_internal_mutable_enddt() {
  
  return enddt_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::release_enddt() {
  // @@protoc_insertion_point(field_release:RetTaskExecElement.endDt)
  return enddt_.Release();
}
inline void RetTaskExecElement::set_allocated_enddt(std::string* enddt) {
  if (enddt != nullptr) {
    
  } else {
    
  }
  enddt_.SetAllocated(enddt, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (enddt_.IsDefault()) {
    enddt_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetTaskExecElement.endDt)
}

// int32 siteId = 7;
inline void RetTaskExecElement::clear_siteid() {
  siteid_ = 0;
}
inline int32_t RetTaskExecElement::_internal_siteid() const {
  return siteid_;
}
inline int32_t RetTaskExecElement::siteid() const {
  // @@protoc_insertion_point(field_get:RetTaskExecElement.siteId)
  return _internal_siteid();
}
inline void RetTaskExecElement::_internal_set_siteid(int32_t value) {
  
  siteid_ = value;
}
inline void RetTaskExecElement::set_siteid(int32_t value) {
  _internal_set_siteid(value);
  // @@protoc_insertion_point(field_set:RetTaskExecElement.siteId)
}

// string siteName = 8;
inline void RetTaskExecElement::clear_sitename() {
  sitename_.ClearToEmpty();
}
inline const std::string& RetTaskExecElement::sitename() const {
  // @@protoc_insertion_point(field_get:RetTaskExecElement.siteName)
  return _internal_sitename();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskExecElement::set_sitename(ArgT0&& arg0, ArgT... args) {
 
 sitename_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetTaskExecElement.siteName)
}
inline std::string* RetTaskExecElement::mutable_sitename() {
  std::string* _s = _internal_mutable_sitename();
  // @@protoc_insertion_point(field_mutable:RetTaskExecElement.siteName)
  return _s;
}
inline const std::string& RetTaskExecElement::_internal_sitename() const {
  return sitename_.Get();
}
inline void RetTaskExecElement::_internal_set_sitename(const std::string& value) {
  
  sitename_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::_internal_mutable_sitename() {
  
  return sitename_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::release_sitename() {
  // @@protoc_insertion_point(field_release:RetTaskExecElement.siteName)
  return sitename_.Release();
}
inline void RetTaskExecElement::set_allocated_sitename(std::string* sitename) {
  if (sitename != nullptr) {
    
  } else {
    
  }
  sitename_.SetAllocated(sitename, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (sitename_.IsDefault()) {
    sitename_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetTaskExecElement.siteName)
}

// string channel = 9;
inline void RetTaskExecElement::clear_channel() {
  channel_.ClearToEmpty();
}
inline const std::string& RetTaskExecElement::channel() const {
  // @@protoc_insertion_point(field_get:RetTaskExecElement.channel)
  return _internal_channel();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskExecElement::set_channel(ArgT0&& arg0, ArgT... args) {
 
 channel_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetTaskExecElement.channel)
}
inline std::string* RetTaskExecElement::mutable_channel() {
  std::string* _s = _internal_mutable_channel();
  // @@protoc_insertion_point(field_mutable:RetTaskExecElement.channel)
  return _s;
}
inline const std::string& RetTaskExecElement::_internal_channel() const {
  return channel_.Get();
}
inline void RetTaskExecElement::_internal_set_channel(const std::string& value) {
  
  channel_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::_internal_mutable_channel() {
  
  return channel_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::release_channel() {
  // @@protoc_insertion_point(field_release:RetTaskExecElement.channel)
  return channel_.Release();
}
inline void RetTaskExecElement::set_allocated_channel(std::string* channel) {
  if (channel != nullptr) {
    
  } else {
    
  }
  channel_.SetAllocated(channel, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (channel_.IsDefault()) {
    channel_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetTaskExecElement.channel)
}

// string radioFQ = 10;
inline void RetTaskExecElement::clear_radiofq() {
  radiofq_.ClearToEmpty();
}
inline const std::string& RetTaskExecElement::radiofq() const {
  // @@protoc_insertion_point(field_get:RetTaskExecElement.radioFQ)
  return _internal_radiofq();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskExecElement::set_radiofq(ArgT0&& arg0, ArgT... args) {
 
 radiofq_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetTaskExecElement.radioFQ)
}
inline std::string* RetTaskExecElement::mutable_radiofq() {
  std::string* _s = _internal_mutable_radiofq();
  // @@protoc_insertion_point(field_mutable:RetTaskExecElement.radioFQ)
  return _s;
}
inline const std::string& RetTaskExecElement::_internal_radiofq() const {
  return radiofq_.Get();
}
inline void RetTaskExecElement::_internal_set_radiofq(const std::string& value) {
  
  radiofq_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::_internal_mutable_radiofq() {
  
  return radiofq_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::release_radiofq() {
  // @@protoc_insertion_point(field_release:RetTaskExecElement.radioFQ)
  return radiofq_.Release();
}
inline void RetTaskExecElement::set_allocated_radiofq(std::string* radiofq) {
  if (radiofq != nullptr) {
    
  } else {
    
  }
  radiofq_.SetAllocated(radiofq, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (radiofq_.IsDefault()) {
    radiofq_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetTaskExecElement.radioFQ)
}

// string signalBW = 11;
inline void RetTaskExecElement::clear_signalbw() {
  signalbw_.ClearToEmpty();
}
inline const std::string& RetTaskExecElement::signalbw() const {
  // @@protoc_insertion_point(field_get:RetTaskExecElement.signalBW)
  return _internal_signalbw();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskExecElement::set_signalbw(ArgT0&& arg0, ArgT... args) {
 
 signalbw_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetTaskExecElement.signalBW)
}
inline std::string* RetTaskExecElement::mutable_signalbw() {
  std::string* _s = _internal_mutable_signalbw();
  // @@protoc_insertion_point(field_mutable:RetTaskExecElement.signalBW)
  return _s;
}
inline const std::string& RetTaskExecElement::_internal_signalbw() const {
  return signalbw_.Get();
}
inline void RetTaskExecElement::_internal_set_signalbw(const std::string& value) {
  
  signalbw_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::_internal_mutable_signalbw() {
  
  return signalbw_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::release_signalbw() {
  // @@protoc_insertion_point(field_release:RetTaskExecElement.signalBW)
  return signalbw_.Release();
}
inline void RetTaskExecElement::set_allocated_signalbw(std::string* signalbw) {
  if (signalbw != nullptr) {
    
  } else {
    
  }
  signalbw_.SetAllocated(signalbw, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (signalbw_.IsDefault()) {
    signalbw_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetTaskExecElement.signalBW)
}

// string carrierFQ = 12;
inline void RetTaskExecElement::clear_carrierfq() {
  carrierfq_.ClearToEmpty();
}
inline const std::string& RetTaskExecElement::carrierfq() const {
  // @@protoc_insertion_point(field_get:RetTaskExecElement.carrierFQ)
  return _internal_carrierfq();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskExecElement::set_carrierfq(ArgT0&& arg0, ArgT... args) {
 
 carrierfq_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetTaskExecElement.carrierFQ)
}
inline std::string* RetTaskExecElement::mutable_carrierfq() {
  std::string* _s = _internal_mutable_carrierfq();
  // @@protoc_insertion_point(field_mutable:RetTaskExecElement.carrierFQ)
  return _s;
}
inline const std::string& RetTaskExecElement::_internal_carrierfq() const {
  return carrierfq_.Get();
}
inline void RetTaskExecElement::_internal_set_carrierfq(const std::string& value) {
  
  carrierfq_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::_internal_mutable_carrierfq() {
  
  return carrierfq_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::release_carrierfq() {
  // @@protoc_insertion_point(field_release:RetTaskExecElement.carrierFQ)
  return carrierfq_.Release();
}
inline void RetTaskExecElement::set_allocated_carrierfq(std::string* carrierfq) {
  if (carrierfq != nullptr) {
    
  } else {
    
  }
  carrierfq_.SetAllocated(carrierfq, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (carrierfq_.IsDefault()) {
    carrierfq_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetTaskExecElement.carrierFQ)
}

// string modRate = 13;
inline void RetTaskExecElement::clear_modrate() {
  modrate_.ClearToEmpty();
}
inline const std::string& RetTaskExecElement::modrate() const {
  // @@protoc_insertion_point(field_get:RetTaskExecElement.modRate)
  return _internal_modrate();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskExecElement::set_modrate(ArgT0&& arg0, ArgT... args) {
 
 modrate_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetTaskExecElement.modRate)
}
inline std::string* RetTaskExecElement::mutable_modrate() {
  std::string* _s = _internal_mutable_modrate();
  // @@protoc_insertion_point(field_mutable:RetTaskExecElement.modRate)
  return _s;
}
inline const std::string& RetTaskExecElement::_internal_modrate() const {
  return modrate_.Get();
}
inline void RetTaskExecElement::_internal_set_modrate(const std::string& value) {
  
  modrate_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::_internal_mutable_modrate() {
  
  return modrate_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::release_modrate() {
  // @@protoc_insertion_point(field_release:RetTaskExecElement.modRate)
  return modrate_.Release();
}
inline void RetTaskExecElement::set_allocated_modrate(std::string* modrate) {
  if (modrate != nullptr) {
    
  } else {
    
  }
  modrate_.SetAllocated(modrate, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (modrate_.IsDefault()) {
    modrate_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetTaskExecElement.modRate)
}

// string modRecognition = 14;
inline void RetTaskExecElement::clear_modrecognition() {
  modrecognition_.ClearToEmpty();
}
inline const std::string& RetTaskExecElement::modrecognition() const {
  // @@protoc_insertion_point(field_get:RetTaskExecElement.modRecognition)
  return _internal_modrecognition();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskExecElement::set_modrecognition(ArgT0&& arg0, ArgT... args) {
 
 modrecognition_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetTaskExecElement.modRecognition)
}
inline std::string* RetTaskExecElement::mutable_modrecognition() {
  std::string* _s = _internal_mutable_modrecognition();
  // @@protoc_insertion_point(field_mutable:RetTaskExecElement.modRecognition)
  return _s;
}
inline const std::string& RetTaskExecElement::_internal_modrecognition() const {
  return modrecognition_.Get();
}
inline void RetTaskExecElement::_internal_set_modrecognition(const std::string& value) {
  
  modrecognition_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::_internal_mutable_modrecognition() {
  
  return modrecognition_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::release_modrecognition() {
  // @@protoc_insertion_point(field_release:RetTaskExecElement.modRecognition)
  return modrecognition_.Release();
}
inline void RetTaskExecElement::set_allocated_modrecognition(std::string* modrecognition) {
  if (modrecognition != nullptr) {
    
  } else {
    
  }
  modrecognition_.SetAllocated(modrecognition, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (modrecognition_.IsDefault()) {
    modrecognition_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetTaskExecElement.modRecognition)
}

// string chirpRate = 15;
inline void RetTaskExecElement::clear_chirprate() {
  chirprate_.ClearToEmpty();
}
inline const std::string& RetTaskExecElement::chirprate() const {
  // @@protoc_insertion_point(field_get:RetTaskExecElement.chirpRate)
  return _internal_chirprate();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskExecElement::set_chirprate(ArgT0&& arg0, ArgT... args) {
 
 chirprate_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetTaskExecElement.chirpRate)
}
inline std::string* RetTaskExecElement::mutable_chirprate() {
  std::string* _s = _internal_mutable_chirprate();
  // @@protoc_insertion_point(field_mutable:RetTaskExecElement.chirpRate)
  return _s;
}
inline const std::string& RetTaskExecElement::_internal_chirprate() const {
  return chirprate_.Get();
}
inline void RetTaskExecElement::_internal_set_chirprate(const std::string& value) {
  
  chirprate_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::_internal_mutable_chirprate() {
  
  return chirprate_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::release_chirprate() {
  // @@protoc_insertion_point(field_release:RetTaskExecElement.chirpRate)
  return chirprate_.Release();
}
inline void RetTaskExecElement::set_allocated_chirprate(std::string* chirprate) {
  if (chirprate != nullptr) {
    
  } else {
    
  }
  chirprate_.SetAllocated(chirprate, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (chirprate_.IsDefault()) {
    chirprate_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetTaskExecElement.chirpRate)
}

// string fmBW = 16;
inline void RetTaskExecElement::clear_fmbw() {
  fmbw_.ClearToEmpty();
}
inline const std::string& RetTaskExecElement::fmbw() const {
  // @@protoc_insertion_point(field_get:RetTaskExecElement.fmBW)
  return _internal_fmbw();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskExecElement::set_fmbw(ArgT0&& arg0, ArgT... args) {
 
 fmbw_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetTaskExecElement.fmBW)
}
inline std::string* RetTaskExecElement::mutable_fmbw() {
  std::string* _s = _internal_mutable_fmbw();
  // @@protoc_insertion_point(field_mutable:RetTaskExecElement.fmBW)
  return _s;
}
inline const std::string& RetTaskExecElement::_internal_fmbw() const {
  return fmbw_.Get();
}
inline void RetTaskExecElement::_internal_set_fmbw(const std::string& value) {
  
  fmbw_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::_internal_mutable_fmbw() {
  
  return fmbw_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::release_fmbw() {
  // @@protoc_insertion_point(field_release:RetTaskExecElement.fmBW)
  return fmbw_.Release();
}
inline void RetTaskExecElement::set_allocated_fmbw(std::string* fmbw) {
  if (fmbw != nullptr) {
    
  } else {
    
  }
  fmbw_.SetAllocated(fmbw, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (fmbw_.IsDefault()) {
    fmbw_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetTaskExecElement.fmBW)
}

// string signalSys = 17;
inline void RetTaskExecElement::clear_signalsys() {
  signalsys_.ClearToEmpty();
}
inline const std::string& RetTaskExecElement::signalsys() const {
  // @@protoc_insertion_point(field_get:RetTaskExecElement.signalSys)
  return _internal_signalsys();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskExecElement::set_signalsys(ArgT0&& arg0, ArgT... args) {
 
 signalsys_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetTaskExecElement.signalSys)
}
inline std::string* RetTaskExecElement::mutable_signalsys() {
  std::string* _s = _internal_mutable_signalsys();
  // @@protoc_insertion_point(field_mutable:RetTaskExecElement.signalSys)
  return _s;
}
inline const std::string& RetTaskExecElement::_internal_signalsys() const {
  return signalsys_.Get();
}
inline void RetTaskExecElement::_internal_set_signalsys(const std::string& value) {
  
  signalsys_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::_internal_mutable_signalsys() {
  
  return signalsys_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::release_signalsys() {
  // @@protoc_insertion_point(field_release:RetTaskExecElement.signalSys)
  return signalsys_.Release();
}
inline void RetTaskExecElement::set_allocated_signalsys(std::string* signalsys) {
  if (signalsys != nullptr) {
    
  } else {
    
  }
  signalsys_.SetAllocated(signalsys, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (signalsys_.IsDefault()) {
    signalsys_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetTaskExecElement.signalSys)
}

// string coding = 18;
inline void RetTaskExecElement::clear_coding() {
  coding_.ClearToEmpty();
}
inline const std::string& RetTaskExecElement::coding() const {
  // @@protoc_insertion_point(field_get:RetTaskExecElement.coding)
  return _internal_coding();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskExecElement::set_coding(ArgT0&& arg0, ArgT... args) {
 
 coding_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetTaskExecElement.coding)
}
inline std::string* RetTaskExecElement::mutable_coding() {
  std::string* _s = _internal_mutable_coding();
  // @@protoc_insertion_point(field_mutable:RetTaskExecElement.coding)
  return _s;
}
inline const std::string& RetTaskExecElement::_internal_coding() const {
  return coding_.Get();
}
inline void RetTaskExecElement::_internal_set_coding(const std::string& value) {
  
  coding_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::_internal_mutable_coding() {
  
  return coding_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::release_coding() {
  // @@protoc_insertion_point(field_release:RetTaskExecElement.coding)
  return coding_.Release();
}
inline void RetTaskExecElement::set_allocated_coding(std::string* coding) {
  if (coding != nullptr) {
    
  } else {
    
  }
  coding_.SetAllocated(coding, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (coding_.IsDefault()) {
    coding_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetTaskExecElement.coding)
}

// string electricPotential = 19;
inline void RetTaskExecElement::clear_electricpotential() {
  electricpotential_.ClearToEmpty();
}
inline const std::string& RetTaskExecElement::electricpotential() const {
  // @@protoc_insertion_point(field_get:RetTaskExecElement.electricPotential)
  return _internal_electricpotential();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskExecElement::set_electricpotential(ArgT0&& arg0, ArgT... args) {
 
 electricpotential_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetTaskExecElement.electricPotential)
}
inline std::string* RetTaskExecElement::mutable_electricpotential() {
  std::string* _s = _internal_mutable_electricpotential();
  // @@protoc_insertion_point(field_mutable:RetTaskExecElement.electricPotential)
  return _s;
}
inline const std::string& RetTaskExecElement::_internal_electricpotential() const {
  return electricpotential_.Get();
}
inline void RetTaskExecElement::_internal_set_electricpotential(const std::string& value) {
  
  electricpotential_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::_internal_mutable_electricpotential() {
  
  return electricpotential_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::release_electricpotential() {
  // @@protoc_insertion_point(field_release:RetTaskExecElement.electricPotential)
  return electricpotential_.Release();
}
inline void RetTaskExecElement::set_allocated_electricpotential(std::string* electricpotential) {
  if (electricpotential != nullptr) {
    
  } else {
    
  }
  electricpotential_.SetAllocated(electricpotential, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (electricpotential_.IsDefault()) {
    electricpotential_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetTaskExecElement.electricPotential)
}

// string snr = 20;
inline void RetTaskExecElement::clear_snr() {
  snr_.ClearToEmpty();
}
inline const std::string& RetTaskExecElement::snr() const {
  // @@protoc_insertion_point(field_get:RetTaskExecElement.snr)
  return _internal_snr();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskExecElement::set_snr(ArgT0&& arg0, ArgT... args) {
 
 snr_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetTaskExecElement.snr)
}
inline std::string* RetTaskExecElement::mutable_snr() {
  std::string* _s = _internal_mutable_snr();
  // @@protoc_insertion_point(field_mutable:RetTaskExecElement.snr)
  return _s;
}
inline const std::string& RetTaskExecElement::_internal_snr() const {
  return snr_.Get();
}
inline void RetTaskExecElement::_internal_set_snr(const std::string& value) {
  
  snr_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::_internal_mutable_snr() {
  
  return snr_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::release_snr() {
  // @@protoc_insertion_point(field_release:RetTaskExecElement.snr)
  return snr_.Release();
}
inline void RetTaskExecElement::set_allocated_snr(std::string* snr) {
  if (snr != nullptr) {
    
  } else {
    
  }
  snr_.SetAllocated(snr, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (snr_.IsDefault()) {
    snr_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetTaskExecElement.snr)
}

// bool signalCheck = 21;
inline void RetTaskExecElement::clear_signalcheck() {
  signalcheck_ = false;
}
inline bool RetTaskExecElement::_internal_signalcheck() const {
  return signalcheck_;
}
inline bool RetTaskExecElement::signalcheck() const {
  // @@protoc_insertion_point(field_get:RetTaskExecElement.signalCheck)
  return _internal_signalcheck();
}
inline void RetTaskExecElement::_internal_set_signalcheck(bool value) {
  
  signalcheck_ = value;
}
inline void RetTaskExecElement::set_signalcheck(bool value) {
  _internal_set_signalcheck(value);
  // @@protoc_insertion_point(field_set:RetTaskExecElement.signalCheck)
}

// string faultDevice = 22;
inline void RetTaskExecElement::clear_faultdevice() {
  faultdevice_.ClearToEmpty();
}
inline const std::string& RetTaskExecElement::faultdevice() const {
  // @@protoc_insertion_point(field_get:RetTaskExecElement.faultDevice)
  return _internal_faultdevice();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskExecElement::set_faultdevice(ArgT0&& arg0, ArgT... args) {
 
 faultdevice_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetTaskExecElement.faultDevice)
}
inline std::string* RetTaskExecElement::mutable_faultdevice() {
  std::string* _s = _internal_mutable_faultdevice();
  // @@protoc_insertion_point(field_mutable:RetTaskExecElement.faultDevice)
  return _s;
}
inline const std::string& RetTaskExecElement::_internal_faultdevice() const {
  return faultdevice_.Get();
}
inline void RetTaskExecElement::_internal_set_faultdevice(const std::string& value) {
  
  faultdevice_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::_internal_mutable_faultdevice() {
  
  return faultdevice_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::release_faultdevice() {
  // @@protoc_insertion_point(field_release:RetTaskExecElement.faultDevice)
  return faultdevice_.Release();
}
inline void RetTaskExecElement::set_allocated_faultdevice(std::string* faultdevice) {
  if (faultdevice != nullptr) {
    
  } else {
    
  }
  faultdevice_.SetAllocated(faultdevice, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (faultdevice_.IsDefault()) {
    faultdevice_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetTaskExecElement.faultDevice)
}

// string faultCode = 23;
inline void RetTaskExecElement::clear_faultcode() {
  faultcode_.ClearToEmpty();
}
inline const std::string& RetTaskExecElement::faultcode() const {
  // @@protoc_insertion_point(field_get:RetTaskExecElement.faultCode)
  return _internal_faultcode();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskExecElement::set_faultcode(ArgT0&& arg0, ArgT... args) {
 
 faultcode_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetTaskExecElement.faultCode)
}
inline std::string* RetTaskExecElement::mutable_faultcode() {
  std::string* _s = _internal_mutable_faultcode();
  // @@protoc_insertion_point(field_mutable:RetTaskExecElement.faultCode)
  return _s;
}
inline const std::string& RetTaskExecElement::_internal_faultcode() const {
  return faultcode_.Get();
}
inline void RetTaskExecElement::_internal_set_faultcode(const std::string& value) {
  
  faultcode_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::_internal_mutable_faultcode() {
  
  return faultcode_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::release_faultcode() {
  // @@protoc_insertion_point(field_release:RetTaskExecElement.faultCode)
  return faultcode_.Release();
}
inline void RetTaskExecElement::set_allocated_faultcode(std::string* faultcode) {
  if (faultcode != nullptr) {
    
  } else {
    
  }
  faultcode_.SetAllocated(faultcode, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (faultcode_.IsDefault()) {
    faultcode_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetTaskExecElement.faultCode)
}

// string echoFileName = 24;
inline void RetTaskExecElement::clear_echofilename() {
  echofilename_.ClearToEmpty();
}
inline const std::string& RetTaskExecElement::echofilename() const {
  // @@protoc_insertion_point(field_get:RetTaskExecElement.echoFileName)
  return _internal_echofilename();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskExecElement::set_echofilename(ArgT0&& arg0, ArgT... args) {
 
 echofilename_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetTaskExecElement.echoFileName)
}
inline std::string* RetTaskExecElement::mutable_echofilename() {
  std::string* _s = _internal_mutable_echofilename();
  // @@protoc_insertion_point(field_mutable:RetTaskExecElement.echoFileName)
  return _s;
}
inline const std::string& RetTaskExecElement::_internal_echofilename() const {
  return echofilename_.Get();
}
inline void RetTaskExecElement::_internal_set_echofilename(const std::string& value) {
  
  echofilename_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::_internal_mutable_echofilename() {
  
  return echofilename_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::release_echofilename() {
  // @@protoc_insertion_point(field_release:RetTaskExecElement.echoFileName)
  return echofilename_.Release();
}
inline void RetTaskExecElement::set_allocated_echofilename(std::string* echofilename) {
  if (echofilename != nullptr) {
    
  } else {
    
  }
  echofilename_.SetAllocated(echofilename, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (echofilename_.IsDefault()) {
    echofilename_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetTaskExecElement.echoFileName)
}

// int32 echoFileSize = 25;
inline void RetTaskExecElement::clear_echofilesize() {
  echofilesize_ = 0;
}
inline int32_t RetTaskExecElement::_internal_echofilesize() const {
  return echofilesize_;
}
inline int32_t RetTaskExecElement::echofilesize() const {
  // @@protoc_insertion_point(field_get:RetTaskExecElement.echoFileSize)
  return _internal_echofilesize();
}
inline void RetTaskExecElement::_internal_set_echofilesize(int32_t value) {
  
  echofilesize_ = value;
}
inline void RetTaskExecElement::set_echofilesize(int32_t value) {
  _internal_set_echofilesize(value);
  // @@protoc_insertion_point(field_set:RetTaskExecElement.echoFileSize)
}

// string echoFilePath = 26;
inline void RetTaskExecElement::clear_echofilepath() {
  echofilepath_.ClearToEmpty();
}
inline const std::string& RetTaskExecElement::echofilepath() const {
  // @@protoc_insertion_point(field_get:RetTaskExecElement.echoFilePath)
  return _internal_echofilepath();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskExecElement::set_echofilepath(ArgT0&& arg0, ArgT... args) {
 
 echofilepath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetTaskExecElement.echoFilePath)
}
inline std::string* RetTaskExecElement::mutable_echofilepath() {
  std::string* _s = _internal_mutable_echofilepath();
  // @@protoc_insertion_point(field_mutable:RetTaskExecElement.echoFilePath)
  return _s;
}
inline const std::string& RetTaskExecElement::_internal_echofilepath() const {
  return echofilepath_.Get();
}
inline void RetTaskExecElement::_internal_set_echofilepath(const std::string& value) {
  
  echofilepath_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::_internal_mutable_echofilepath() {
  
  return echofilepath_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskExecElement::release_echofilepath() {
  // @@protoc_insertion_point(field_release:RetTaskExecElement.echoFilePath)
  return echofilepath_.Release();
}
inline void RetTaskExecElement::set_allocated_echofilepath(std::string* echofilepath) {
  if (echofilepath != nullptr) {
    
  } else {
    
  }
  echofilepath_.SetAllocated(echofilepath, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (echofilepath_.IsDefault()) {
    echofilepath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetTaskExecElement.echoFilePath)
}

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

// ReqTaskExecDetailSpec

// int32 id = 1;
inline void ReqTaskExecDetailSpec::clear_id() {
  id_ = 0;
}
inline int32_t ReqTaskExecDetailSpec::_internal_id() const {
  return id_;
}
inline int32_t ReqTaskExecDetailSpec::id() const {
  // @@protoc_insertion_point(field_get:ReqTaskExecDetailSpec.id)
  return _internal_id();
}
inline void ReqTaskExecDetailSpec::_internal_set_id(int32_t value) {
  
  id_ = value;
}
inline void ReqTaskExecDetailSpec::set_id(int32_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:ReqTaskExecDetailSpec.id)
}

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

// RetTaskExecDetailSpec

// int32 freq = 1;
inline void RetTaskExecDetailSpec::clear_freq() {
  freq_ = 0;
}
inline int32_t RetTaskExecDetailSpec::_internal_freq() const {
  return freq_;
}
inline int32_t RetTaskExecDetailSpec::freq() const {
  // @@protoc_insertion_point(field_get:RetTaskExecDetailSpec.freq)
  return _internal_freq();
}
inline void RetTaskExecDetailSpec::_internal_set_freq(int32_t value) {
  
  freq_ = value;
}
inline void RetTaskExecDetailSpec::set_freq(int32_t value) {
  _internal_set_freq(value);
  // @@protoc_insertion_point(field_set:RetTaskExecDetailSpec.freq)
}

// int32 dbm = 2;
inline void RetTaskExecDetailSpec::clear_dbm() {
  dbm_ = 0;
}
inline int32_t RetTaskExecDetailSpec::_internal_dbm() const {
  return dbm_;
}
inline int32_t RetTaskExecDetailSpec::dbm() const {
  // @@protoc_insertion_point(field_get:RetTaskExecDetailSpec.dbm)
  return _internal_dbm();
}
inline void RetTaskExecDetailSpec::_internal_set_dbm(int32_t value) {
  
  dbm_ = value;
}
inline void RetTaskExecDetailSpec::set_dbm(int32_t value) {
  _internal_set_dbm(value);
  // @@protoc_insertion_point(field_set:RetTaskExecDetailSpec.dbm)
}

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

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

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


// @@protoc_insertion_point(namespace_scope)


// @@protoc_insertion_point(global_scope)

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