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

#ifndef GOOGLE_PROTOBUF_INCLUDED_mod_2dtask_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_mod_2dtask_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/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_mod_2dtask_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_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_mod_2dtask_2eproto;
namespace satllite {
namespace protobuf {
namespace task {
class ReqTaskDel;
struct ReqTaskDelDefaultTypeInternal;
extern ReqTaskDelDefaultTypeInternal _ReqTaskDel_default_instance_;
class ReqTaskDetailDat;
struct ReqTaskDetailDatDefaultTypeInternal;
extern ReqTaskDetailDatDefaultTypeInternal _ReqTaskDetailDat_default_instance_;
class ReqTaskDetailPoint;
struct ReqTaskDetailPointDefaultTypeInternal;
extern ReqTaskDetailPointDefaultTypeInternal _ReqTaskDetailPoint_default_instance_;
class ReqTaskForecast;
struct ReqTaskForecastDefaultTypeInternal;
extern ReqTaskForecastDefaultTypeInternal _ReqTaskForecast_default_instance_;
class ReqTaskList;
struct ReqTaskListDefaultTypeInternal;
extern ReqTaskListDefaultTypeInternal _ReqTaskList_default_instance_;
class ReqTaskUpdate;
struct ReqTaskUpdateDefaultTypeInternal;
extern ReqTaskUpdateDefaultTypeInternal _ReqTaskUpdate_default_instance_;
class RetTaskDat;
struct RetTaskDatDefaultTypeInternal;
extern RetTaskDatDefaultTypeInternal _RetTaskDat_default_instance_;
class RetTaskElement;
struct RetTaskElementDefaultTypeInternal;
extern RetTaskElementDefaultTypeInternal _RetTaskElement_default_instance_;
class RetTaskPoint;
struct RetTaskPointDefaultTypeInternal;
extern RetTaskPointDefaultTypeInternal _RetTaskPoint_default_instance_;
}  // namespace task
}  // namespace protobuf
}  // namespace satllite
PROTOBUF_NAMESPACE_OPEN
template<> ::satllite::protobuf::task::ReqTaskDel* Arena::CreateMaybeMessage<::satllite::protobuf::task::ReqTaskDel>(Arena*);
template<> ::satllite::protobuf::task::ReqTaskDetailDat* Arena::CreateMaybeMessage<::satllite::protobuf::task::ReqTaskDetailDat>(Arena*);
template<> ::satllite::protobuf::task::ReqTaskDetailPoint* Arena::CreateMaybeMessage<::satllite::protobuf::task::ReqTaskDetailPoint>(Arena*);
template<> ::satllite::protobuf::task::ReqTaskForecast* Arena::CreateMaybeMessage<::satllite::protobuf::task::ReqTaskForecast>(Arena*);
template<> ::satllite::protobuf::task::ReqTaskList* Arena::CreateMaybeMessage<::satllite::protobuf::task::ReqTaskList>(Arena*);
template<> ::satllite::protobuf::task::ReqTaskUpdate* Arena::CreateMaybeMessage<::satllite::protobuf::task::ReqTaskUpdate>(Arena*);
template<> ::satllite::protobuf::task::RetTaskDat* Arena::CreateMaybeMessage<::satllite::protobuf::task::RetTaskDat>(Arena*);
template<> ::satllite::protobuf::task::RetTaskElement* Arena::CreateMaybeMessage<::satllite::protobuf::task::RetTaskElement>(Arena*);
template<> ::satllite::protobuf::task::RetTaskPoint* Arena::CreateMaybeMessage<::satllite::protobuf::task::RetTaskPoint>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace satllite {
namespace protobuf {
namespace task {

enum TaskStatus : int {
  StatusInit = 0,
  StatusUndo = 1,
  StatusWaiting = 2,
  StatusDoing = 3,
  StatusDone = 4,
  StatusFailed = 10,
  TaskStatus_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  TaskStatus_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool TaskStatus_IsValid(int value);
constexpr TaskStatus TaskStatus_MIN = StatusInit;
constexpr TaskStatus TaskStatus_MAX = StatusFailed;
constexpr int TaskStatus_ARRAYSIZE = TaskStatus_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TaskStatus_descriptor();
template<typename T>
inline const std::string& TaskStatus_Name(T enum_t_value) {
  static_assert(::std::is_same<T, TaskStatus>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function TaskStatus_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    TaskStatus_descriptor(), enum_t_value);
}
inline bool TaskStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TaskStatus* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TaskStatus>(
    TaskStatus_descriptor(), name, value);
}
enum TaskGrade : int {
  GradeNone = 0,
  GradeNormal = 1,
  GradeImportant = 2,
  GradeUrgent = 3,
  TaskGrade_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  TaskGrade_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool TaskGrade_IsValid(int value);
constexpr TaskGrade TaskGrade_MIN = GradeNone;
constexpr TaskGrade TaskGrade_MAX = GradeUrgent;
constexpr int TaskGrade_ARRAYSIZE = TaskGrade_MAX + 1;

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

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

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

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

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

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

  ReqTaskForecast* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ReqTaskForecast>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ReqTaskForecast& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ReqTaskForecast& 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(ReqTaskForecast* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "satllite.protobuf.task.ReqTaskForecast";
  }
  protected:
  explicit ReqTaskForecast(::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 {
    kSatelliteFieldNumber = 1,
    kStartFieldNumber = 5,
    kEndFieldNumber = 6,
    kSliceFieldNumber = 3,
    kMinEleAngleFieldNumber = 4,
    kSiteFieldNumber = 2,
    kGradeFieldNumber = 7,
    kUidFieldNumber = 8,
  };
  // repeated int32 satellite = 1;
  int satellite_size() const;
  private:
  int _internal_satellite_size() const;
  public:
  void clear_satellite();
  private:
  int32_t _internal_satellite(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_satellite() const;
  void _internal_add_satellite(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_satellite();
  public:
  int32_t satellite(int index) const;
  void set_satellite(int index, int32_t value);
  void add_satellite(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      satellite() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_satellite();

  // string start = 5;
  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 = 6;
  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:

  // double slice = 3;
  void clear_slice();
  double slice() const;
  void set_slice(double value);
  private:
  double _internal_slice() const;
  void _internal_set_slice(double value);
  public:

  // double minEleAngle = 4;
  void clear_mineleangle();
  double mineleangle() const;
  void set_mineleangle(double value);
  private:
  double _internal_mineleangle() const;
  void _internal_set_mineleangle(double value);
  public:

  // int32 site = 2;
  void clear_site();
  int32_t site() const;
  void set_site(int32_t value);
  private:
  int32_t _internal_site() const;
  void _internal_set_site(int32_t value);
  public:

  // .satllite.protobuf.task.TaskGrade grade = 7;
  void clear_grade();
  ::satllite::protobuf::task::TaskGrade grade() const;
  void set_grade(::satllite::protobuf::task::TaskGrade value);
  private:
  ::satllite::protobuf::task::TaskGrade _internal_grade() const;
  void _internal_set_grade(::satllite::protobuf::task::TaskGrade value);
  public:

  // int32 uid = 8;
  void clear_uid();
  int32_t uid() const;
  void set_uid(int32_t value);
  private:
  int32_t _internal_uid() const;
  void _internal_set_uid(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:satllite.protobuf.task.ReqTaskForecast)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > satellite_;
  mutable std::atomic<int> _satellite_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr start_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr end_;
  double slice_;
  double mineleangle_;
  int32_t site_;
  int grade_;
  int32_t uid_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2dtask_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

  ReqTaskList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ReqTaskList>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ReqTaskList& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ReqTaskList& 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(ReqTaskList* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "satllite.protobuf.task.ReqTaskList";
  }
  protected:
  explicit ReqTaskList(::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 {
    kStatusFieldNumber = 1,
    kCodeSearchFieldNumber = 2,
    kNoSearchFieldNumber = 3,
    kStartFieldNumber = 5,
    kEndFieldNumber = 6,
    kGradeFieldNumber = 4,
  };
  // repeated .satllite.protobuf.task.TaskStatus status = 1;
  int status_size() const;
  private:
  int _internal_status_size() const;
  public:
  void clear_status();
  private:
  ::satllite::protobuf::task::TaskStatus _internal_status(int index) const;
  void _internal_add_status(::satllite::protobuf::task::TaskStatus value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_status();
  public:
  ::satllite::protobuf::task::TaskStatus status(int index) const;
  void set_status(int index, ::satllite::protobuf::task::TaskStatus value);
  void add_status(::satllite::protobuf::task::TaskStatus value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& status() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_status();

  // string codeSearch = 2;
  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 = 3;
  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 = 5;
  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 = 6;
  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:

  // .satllite.protobuf.task.TaskGrade grade = 4;
  void clear_grade();
  ::satllite::protobuf::task::TaskGrade grade() const;
  void set_grade(::satllite::protobuf::task::TaskGrade value);
  private:
  ::satllite::protobuf::task::TaskGrade _internal_grade() const;
  void _internal_set_grade(::satllite::protobuf::task::TaskGrade value);
  public:

  // @@protoc_insertion_point(class_scope:satllite.protobuf.task.ReqTaskList)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> status_;
  mutable std::atomic<int> _status_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr codesearch_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr nosearch_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr start_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr end_;
  int grade_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2dtask_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

  RetTaskElement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RetTaskElement>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RetTaskElement& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const RetTaskElement& 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(RetTaskElement* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "satllite.protobuf.task.RetTaskElement";
  }
  protected:
  explicit RetTaskElement(::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,
    kSNameFieldNumber = 5,
    kStartDtFieldNumber = 7,
    kEndDtFieldNumber = 8,
    kSiteNameFieldNumber = 21,
    kIdFieldNumber = 1,
    kCircleFieldNumber = 6,
    kDurationFieldNumber = 9,
    kStatusFieldNumber = 10,
    kStartAziAngleFieldNumber = 11,
    kEndAziAngleFieldNumber = 12,
    kStartEleAngleFieldNumber = 13,
    kMaxEleAngleFieldNumber = 14,
    kMinDistFieldNumber = 15,
    kMaxDistFieldNumber = 16,
    kConflictFieldNumber = 17,
    kShortageFieldNumber = 18,
    kGradeFieldNumber = 19,
    kSiteIdFieldNumber = 20,
  };
  // 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 sName = 5;
  void clear_sname();
  const std::string& sname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sname();
  PROTOBUF_NODISCARD std::string* release_sname();
  void set_allocated_sname(std::string* sname);
  private:
  const std::string& _internal_sname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sname(const std::string& value);
  std::string* _internal_mutable_sname();
  public:

  // string startDt = 7;
  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 = 8;
  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 = 21;
  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:

  // 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 circle = 6;
  void clear_circle();
  int32_t circle() const;
  void set_circle(int32_t value);
  private:
  int32_t _internal_circle() const;
  void _internal_set_circle(int32_t value);
  public:

  // int32 duration = 9;
  void clear_duration();
  int32_t duration() const;
  void set_duration(int32_t value);
  private:
  int32_t _internal_duration() const;
  void _internal_set_duration(int32_t value);
  public:

  // .satllite.protobuf.task.TaskStatus status = 10;
  void clear_status();
  ::satllite::protobuf::task::TaskStatus status() const;
  void set_status(::satllite::protobuf::task::TaskStatus value);
  private:
  ::satllite::protobuf::task::TaskStatus _internal_status() const;
  void _internal_set_status(::satllite::protobuf::task::TaskStatus value);
  public:

  // double startAziAngle = 11;
  void clear_startaziangle();
  double startaziangle() const;
  void set_startaziangle(double value);
  private:
  double _internal_startaziangle() const;
  void _internal_set_startaziangle(double value);
  public:

  // double endAziAngle = 12;
  void clear_endaziangle();
  double endaziangle() const;
  void set_endaziangle(double value);
  private:
  double _internal_endaziangle() const;
  void _internal_set_endaziangle(double value);
  public:

  // double startEleAngle = 13;
  void clear_starteleangle();
  double starteleangle() const;
  void set_starteleangle(double value);
  private:
  double _internal_starteleangle() const;
  void _internal_set_starteleangle(double value);
  public:

  // double maxEleAngle = 14;
  void clear_maxeleangle();
  double maxeleangle() const;
  void set_maxeleangle(double value);
  private:
  double _internal_maxeleangle() const;
  void _internal_set_maxeleangle(double value);
  public:

  // double minDist = 15;
  void clear_mindist();
  double mindist() const;
  void set_mindist(double value);
  private:
  double _internal_mindist() const;
  void _internal_set_mindist(double value);
  public:

  // double maxDist = 16;
  void clear_maxdist();
  double maxdist() const;
  void set_maxdist(double value);
  private:
  double _internal_maxdist() const;
  void _internal_set_maxdist(double value);
  public:

  // bool conflict = 17;
  void clear_conflict();
  bool conflict() const;
  void set_conflict(bool value);
  private:
  bool _internal_conflict() const;
  void _internal_set_conflict(bool value);
  public:

  // bool shortage = 18;
  void clear_shortage();
  bool shortage() const;
  void set_shortage(bool value);
  private:
  bool _internal_shortage() const;
  void _internal_set_shortage(bool value);
  public:

  // .satllite.protobuf.task.TaskGrade grade = 19;
  void clear_grade();
  ::satllite::protobuf::task::TaskGrade grade() const;
  void set_grade(::satllite::protobuf::task::TaskGrade value);
  private:
  ::satllite::protobuf::task::TaskGrade _internal_grade() const;
  void _internal_set_grade(::satllite::protobuf::task::TaskGrade value);
  public:

  // int32 siteId = 20;
  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:

  // @@protoc_insertion_point(class_scope:satllite.protobuf.task.RetTaskElement)
 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 sname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr startdt_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr enddt_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sitename_;
  int32_t id_;
  int32_t circle_;
  int32_t duration_;
  int status_;
  double startaziangle_;
  double endaziangle_;
  double starteleangle_;
  double maxeleangle_;
  double mindist_;
  double maxdist_;
  bool conflict_;
  bool shortage_;
  int grade_;
  int32_t siteid_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2dtask_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

  ReqTaskDel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ReqTaskDel>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ReqTaskDel& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ReqTaskDel& 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(ReqTaskDel* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "satllite.protobuf.task.ReqTaskDel";
  }
  protected:
  explicit ReqTaskDel(::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,
    kUidFieldNumber = 2,
  };
  // repeated int32 id = 1;
  int id_size() const;
  private:
  int _internal_id_size() const;
  public:
  void clear_id();
  private:
  int32_t _internal_id(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_id() const;
  void _internal_add_id(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_id();
  public:
  int32_t id(int index) const;
  void set_id(int index, int32_t value);
  void add_id(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      id() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_id();

  // int32 uid = 2;
  void clear_uid();
  int32_t uid() const;
  void set_uid(int32_t value);
  private:
  int32_t _internal_uid() const;
  void _internal_set_uid(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:satllite.protobuf.task.ReqTaskDel)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > id_;
  mutable std::atomic<int> _id_cached_byte_size_;
  int32_t uid_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2dtask_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

  ReqTaskDetailDat* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ReqTaskDetailDat>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ReqTaskDetailDat& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ReqTaskDetailDat& 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(ReqTaskDetailDat* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "satllite.protobuf.task.ReqTaskDetailDat";
  }
  protected:
  explicit ReqTaskDetailDat(::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:satllite.protobuf.task.ReqTaskDetailDat)
 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_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

  RetTaskDat* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RetTaskDat>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RetTaskDat& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const RetTaskDat& 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(RetTaskDat* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "satllite.protobuf.task.RetTaskDat";
  }
  protected:
  explicit RetTaskDat(::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 {
    kDateFieldNumber = 1,
    kTimeFieldNumber = 2,
    kAziAngleFieldNumber = 3,
    kEleAngleFieldNumber = 4,
  };
  // string date = 1;
  void clear_date();
  const std::string& date() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_date(ArgT0&& arg0, ArgT... args);
  std::string* mutable_date();
  PROTOBUF_NODISCARD std::string* release_date();
  void set_allocated_date(std::string* date);
  private:
  const std::string& _internal_date() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_date(const std::string& value);
  std::string* _internal_mutable_date();
  public:

  // string time = 2;
  void clear_time();
  const std::string& time() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_time(ArgT0&& arg0, ArgT... args);
  std::string* mutable_time();
  PROTOBUF_NODISCARD std::string* release_time();
  void set_allocated_time(std::string* time);
  private:
  const std::string& _internal_time() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_time(const std::string& value);
  std::string* _internal_mutable_time();
  public:

  // string aziAngle = 3;
  void clear_aziangle();
  const std::string& aziangle() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_aziangle(ArgT0&& arg0, ArgT... args);
  std::string* mutable_aziangle();
  PROTOBUF_NODISCARD std::string* release_aziangle();
  void set_allocated_aziangle(std::string* aziangle);
  private:
  const std::string& _internal_aziangle() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_aziangle(const std::string& value);
  std::string* _internal_mutable_aziangle();
  public:

  // string eleAngle = 4;
  void clear_eleangle();
  const std::string& eleangle() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_eleangle(ArgT0&& arg0, ArgT... args);
  std::string* mutable_eleangle();
  PROTOBUF_NODISCARD std::string* release_eleangle();
  void set_allocated_eleangle(std::string* eleangle);
  private:
  const std::string& _internal_eleangle() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_eleangle(const std::string& value);
  std::string* _internal_mutable_eleangle();
  public:

  // @@protoc_insertion_point(class_scope:satllite.protobuf.task.RetTaskDat)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr date_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr time_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr aziangle_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr eleangle_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2dtask_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

  ReqTaskDetailPoint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ReqTaskDetailPoint>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ReqTaskDetailPoint& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ReqTaskDetailPoint& 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(ReqTaskDetailPoint* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "satllite.protobuf.task.ReqTaskDetailPoint";
  }
  protected:
  explicit ReqTaskDetailPoint(::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:satllite.protobuf.task.ReqTaskDetailPoint)
 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_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

  RetTaskPoint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RetTaskPoint>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RetTaskPoint& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const RetTaskPoint& 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(RetTaskPoint* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "satllite.protobuf.task.RetTaskPoint";
  }
  protected:
  explicit RetTaskPoint(::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 {
    kDateFieldNumber = 1,
    kTimeFieldNumber = 2,
    kXFieldNumber = 3,
    kYFieldNumber = 4,
    kZFieldNumber = 5,
    kLatFieldNumber = 6,
    kLonFieldNumber = 7,
    kAltFieldNumber = 8,
  };
  // string date = 1;
  void clear_date();
  const std::string& date() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_date(ArgT0&& arg0, ArgT... args);
  std::string* mutable_date();
  PROTOBUF_NODISCARD std::string* release_date();
  void set_allocated_date(std::string* date);
  private:
  const std::string& _internal_date() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_date(const std::string& value);
  std::string* _internal_mutable_date();
  public:

  // string time = 2;
  void clear_time();
  const std::string& time() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_time(ArgT0&& arg0, ArgT... args);
  std::string* mutable_time();
  PROTOBUF_NODISCARD std::string* release_time();
  void set_allocated_time(std::string* time);
  private:
  const std::string& _internal_time() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_time(const std::string& value);
  std::string* _internal_mutable_time();
  public:

  // string x = 3;
  void clear_x();
  const std::string& x() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_x(ArgT0&& arg0, ArgT... args);
  std::string* mutable_x();
  PROTOBUF_NODISCARD std::string* release_x();
  void set_allocated_x(std::string* x);
  private:
  const std::string& _internal_x() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_x(const std::string& value);
  std::string* _internal_mutable_x();
  public:

  // string y = 4;
  void clear_y();
  const std::string& y() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_y(ArgT0&& arg0, ArgT... args);
  std::string* mutable_y();
  PROTOBUF_NODISCARD std::string* release_y();
  void set_allocated_y(std::string* y);
  private:
  const std::string& _internal_y() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_y(const std::string& value);
  std::string* _internal_mutable_y();
  public:

  // string z = 5;
  void clear_z();
  const std::string& z() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_z(ArgT0&& arg0, ArgT... args);
  std::string* mutable_z();
  PROTOBUF_NODISCARD std::string* release_z();
  void set_allocated_z(std::string* z);
  private:
  const std::string& _internal_z() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_z(const std::string& value);
  std::string* _internal_mutable_z();
  public:

  // string lat = 6;
  void clear_lat();
  const std::string& lat() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_lat(ArgT0&& arg0, ArgT... args);
  std::string* mutable_lat();
  PROTOBUF_NODISCARD std::string* release_lat();
  void set_allocated_lat(std::string* lat);
  private:
  const std::string& _internal_lat() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_lat(const std::string& value);
  std::string* _internal_mutable_lat();
  public:

  // string lon = 7;
  void clear_lon();
  const std::string& lon() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_lon(ArgT0&& arg0, ArgT... args);
  std::string* mutable_lon();
  PROTOBUF_NODISCARD std::string* release_lon();
  void set_allocated_lon(std::string* lon);
  private:
  const std::string& _internal_lon() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_lon(const std::string& value);
  std::string* _internal_mutable_lon();
  public:

  // string alt = 8;
  void clear_alt();
  const std::string& alt() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_alt(ArgT0&& arg0, ArgT... args);
  std::string* mutable_alt();
  PROTOBUF_NODISCARD std::string* release_alt();
  void set_allocated_alt(std::string* alt);
  private:
  const std::string& _internal_alt() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_alt(const std::string& value);
  std::string* _internal_mutable_alt();
  public:

  // @@protoc_insertion_point(class_scope:satllite.protobuf.task.RetTaskPoint)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr date_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr time_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr x_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr y_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr z_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr lat_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr lon_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr alt_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2dtask_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

  ReqTaskUpdate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ReqTaskUpdate>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ReqTaskUpdate& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ReqTaskUpdate& 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(ReqTaskUpdate* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "satllite.protobuf.task.ReqTaskUpdate";
  }
  protected:
  explicit ReqTaskUpdate(::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,
    kUidFieldNumber = 2,
    kStatusFieldNumber = 3,
    kGradeFieldNumber = 4,
  };
  // repeated int32 id = 1;
  int id_size() const;
  private:
  int _internal_id_size() const;
  public:
  void clear_id();
  private:
  int32_t _internal_id(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_id() const;
  void _internal_add_id(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_id();
  public:
  int32_t id(int index) const;
  void set_id(int index, int32_t value);
  void add_id(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      id() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_id();

  // int32 uid = 2;
  void clear_uid();
  int32_t uid() const;
  void set_uid(int32_t value);
  private:
  int32_t _internal_uid() const;
  void _internal_set_uid(int32_t value);
  public:

  // .satllite.protobuf.task.TaskStatus status = 3;
  void clear_status();
  ::satllite::protobuf::task::TaskStatus status() const;
  void set_status(::satllite::protobuf::task::TaskStatus value);
  private:
  ::satllite::protobuf::task::TaskStatus _internal_status() const;
  void _internal_set_status(::satllite::protobuf::task::TaskStatus value);
  public:

  // .satllite.protobuf.task.TaskGrade grade = 4;
  void clear_grade();
  ::satllite::protobuf::task::TaskGrade grade() const;
  void set_grade(::satllite::protobuf::task::TaskGrade value);
  private:
  ::satllite::protobuf::task::TaskGrade _internal_grade() const;
  void _internal_set_grade(::satllite::protobuf::task::TaskGrade value);
  public:

  // @@protoc_insertion_point(class_scope:satllite.protobuf.task.ReqTaskUpdate)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > id_;
  mutable std::atomic<int> _id_cached_byte_size_;
  int32_t uid_;
  int status_;
  int grade_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2dtask_2eproto;
};
// ===================================================================


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

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

// repeated int32 satellite = 1;
inline int ReqTaskForecast::_internal_satellite_size() const {
  return satellite_.size();
}
inline int ReqTaskForecast::satellite_size() const {
  return _internal_satellite_size();
}
inline void ReqTaskForecast::clear_satellite() {
  satellite_.Clear();
}
inline int32_t ReqTaskForecast::_internal_satellite(int index) const {
  return satellite_.Get(index);
}
inline int32_t ReqTaskForecast::satellite(int index) const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.ReqTaskForecast.satellite)
  return _internal_satellite(index);
}
inline void ReqTaskForecast::set_satellite(int index, int32_t value) {
  satellite_.Set(index, value);
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.ReqTaskForecast.satellite)
}
inline void ReqTaskForecast::_internal_add_satellite(int32_t value) {
  satellite_.Add(value);
}
inline void ReqTaskForecast::add_satellite(int32_t value) {
  _internal_add_satellite(value);
  // @@protoc_insertion_point(field_add:satllite.protobuf.task.ReqTaskForecast.satellite)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
ReqTaskForecast::_internal_satellite() const {
  return satellite_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
ReqTaskForecast::satellite() const {
  // @@protoc_insertion_point(field_list:satllite.protobuf.task.ReqTaskForecast.satellite)
  return _internal_satellite();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
ReqTaskForecast::_internal_mutable_satellite() {
  return &satellite_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
ReqTaskForecast::mutable_satellite() {
  // @@protoc_insertion_point(field_mutable_list:satllite.protobuf.task.ReqTaskForecast.satellite)
  return _internal_mutable_satellite();
}

// int32 site = 2;
inline void ReqTaskForecast::clear_site() {
  site_ = 0;
}
inline int32_t ReqTaskForecast::_internal_site() const {
  return site_;
}
inline int32_t ReqTaskForecast::site() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.ReqTaskForecast.site)
  return _internal_site();
}
inline void ReqTaskForecast::_internal_set_site(int32_t value) {
  
  site_ = value;
}
inline void ReqTaskForecast::set_site(int32_t value) {
  _internal_set_site(value);
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.ReqTaskForecast.site)
}

// double slice = 3;
inline void ReqTaskForecast::clear_slice() {
  slice_ = 0;
}
inline double ReqTaskForecast::_internal_slice() const {
  return slice_;
}
inline double ReqTaskForecast::slice() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.ReqTaskForecast.slice)
  return _internal_slice();
}
inline void ReqTaskForecast::_internal_set_slice(double value) {
  
  slice_ = value;
}
inline void ReqTaskForecast::set_slice(double value) {
  _internal_set_slice(value);
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.ReqTaskForecast.slice)
}

// double minEleAngle = 4;
inline void ReqTaskForecast::clear_mineleangle() {
  mineleangle_ = 0;
}
inline double ReqTaskForecast::_internal_mineleangle() const {
  return mineleangle_;
}
inline double ReqTaskForecast::mineleangle() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.ReqTaskForecast.minEleAngle)
  return _internal_mineleangle();
}
inline void ReqTaskForecast::_internal_set_mineleangle(double value) {
  
  mineleangle_ = value;
}
inline void ReqTaskForecast::set_mineleangle(double value) {
  _internal_set_mineleangle(value);
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.ReqTaskForecast.minEleAngle)
}

// string start = 5;
inline void ReqTaskForecast::clear_start() {
  start_.ClearToEmpty();
}
inline const std::string& ReqTaskForecast::start() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.ReqTaskForecast.start)
  return _internal_start();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqTaskForecast::set_start(ArgT0&& arg0, ArgT... args) {
 
 start_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.ReqTaskForecast.start)
}
inline std::string* ReqTaskForecast::mutable_start() {
  std::string* _s = _internal_mutable_start();
  // @@protoc_insertion_point(field_mutable:satllite.protobuf.task.ReqTaskForecast.start)
  return _s;
}
inline const std::string& ReqTaskForecast::_internal_start() const {
  return start_.Get();
}
inline void ReqTaskForecast::_internal_set_start(const std::string& value) {
  
  start_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqTaskForecast::_internal_mutable_start() {
  
  return start_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqTaskForecast::release_start() {
  // @@protoc_insertion_point(field_release:satllite.protobuf.task.ReqTaskForecast.start)
  return start_.Release();
}
inline void ReqTaskForecast::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:satllite.protobuf.task.ReqTaskForecast.start)
}

// string end = 6;
inline void ReqTaskForecast::clear_end() {
  end_.ClearToEmpty();
}
inline const std::string& ReqTaskForecast::end() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.ReqTaskForecast.end)
  return _internal_end();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqTaskForecast::set_end(ArgT0&& arg0, ArgT... args) {
 
 end_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.ReqTaskForecast.end)
}
inline std::string* ReqTaskForecast::mutable_end() {
  std::string* _s = _internal_mutable_end();
  // @@protoc_insertion_point(field_mutable:satllite.protobuf.task.ReqTaskForecast.end)
  return _s;
}
inline const std::string& ReqTaskForecast::_internal_end() const {
  return end_.Get();
}
inline void ReqTaskForecast::_internal_set_end(const std::string& value) {
  
  end_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqTaskForecast::_internal_mutable_end() {
  
  return end_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqTaskForecast::release_end() {
  // @@protoc_insertion_point(field_release:satllite.protobuf.task.ReqTaskForecast.end)
  return end_.Release();
}
inline void ReqTaskForecast::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:satllite.protobuf.task.ReqTaskForecast.end)
}

// .satllite.protobuf.task.TaskGrade grade = 7;
inline void ReqTaskForecast::clear_grade() {
  grade_ = 0;
}
inline ::satllite::protobuf::task::TaskGrade ReqTaskForecast::_internal_grade() const {
  return static_cast< ::satllite::protobuf::task::TaskGrade >(grade_);
}
inline ::satllite::protobuf::task::TaskGrade ReqTaskForecast::grade() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.ReqTaskForecast.grade)
  return _internal_grade();
}
inline void ReqTaskForecast::_internal_set_grade(::satllite::protobuf::task::TaskGrade value) {
  
  grade_ = value;
}
inline void ReqTaskForecast::set_grade(::satllite::protobuf::task::TaskGrade value) {
  _internal_set_grade(value);
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.ReqTaskForecast.grade)
}

// int32 uid = 8;
inline void ReqTaskForecast::clear_uid() {
  uid_ = 0;
}
inline int32_t ReqTaskForecast::_internal_uid() const {
  return uid_;
}
inline int32_t ReqTaskForecast::uid() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.ReqTaskForecast.uid)
  return _internal_uid();
}
inline void ReqTaskForecast::_internal_set_uid(int32_t value) {
  
  uid_ = value;
}
inline void ReqTaskForecast::set_uid(int32_t value) {
  _internal_set_uid(value);
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.ReqTaskForecast.uid)
}

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

// ReqTaskList

// repeated .satllite.protobuf.task.TaskStatus status = 1;
inline int ReqTaskList::_internal_status_size() const {
  return status_.size();
}
inline int ReqTaskList::status_size() const {
  return _internal_status_size();
}
inline void ReqTaskList::clear_status() {
  status_.Clear();
}
inline ::satllite::protobuf::task::TaskStatus ReqTaskList::_internal_status(int index) const {
  return static_cast< ::satllite::protobuf::task::TaskStatus >(status_.Get(index));
}
inline ::satllite::protobuf::task::TaskStatus ReqTaskList::status(int index) const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.ReqTaskList.status)
  return _internal_status(index);
}
inline void ReqTaskList::set_status(int index, ::satllite::protobuf::task::TaskStatus value) {
  status_.Set(index, value);
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.ReqTaskList.status)
}
inline void ReqTaskList::_internal_add_status(::satllite::protobuf::task::TaskStatus value) {
  status_.Add(value);
}
inline void ReqTaskList::add_status(::satllite::protobuf::task::TaskStatus value) {
  _internal_add_status(value);
  // @@protoc_insertion_point(field_add:satllite.protobuf.task.ReqTaskList.status)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
ReqTaskList::status() const {
  // @@protoc_insertion_point(field_list:satllite.protobuf.task.ReqTaskList.status)
  return status_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
ReqTaskList::_internal_mutable_status() {
  return &status_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
ReqTaskList::mutable_status() {
  // @@protoc_insertion_point(field_mutable_list:satllite.protobuf.task.ReqTaskList.status)
  return _internal_mutable_status();
}

// string codeSearch = 2;
inline void ReqTaskList::clear_codesearch() {
  codesearch_.ClearToEmpty();
}
inline const std::string& ReqTaskList::codesearch() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.ReqTaskList.codeSearch)
  return _internal_codesearch();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqTaskList::set_codesearch(ArgT0&& arg0, ArgT... args) {
 
 codesearch_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.ReqTaskList.codeSearch)
}
inline std::string* ReqTaskList::mutable_codesearch() {
  std::string* _s = _internal_mutable_codesearch();
  // @@protoc_insertion_point(field_mutable:satllite.protobuf.task.ReqTaskList.codeSearch)
  return _s;
}
inline const std::string& ReqTaskList::_internal_codesearch() const {
  return codesearch_.Get();
}
inline void ReqTaskList::_internal_set_codesearch(const std::string& value) {
  
  codesearch_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqTaskList::_internal_mutable_codesearch() {
  
  return codesearch_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqTaskList::release_codesearch() {
  // @@protoc_insertion_point(field_release:satllite.protobuf.task.ReqTaskList.codeSearch)
  return codesearch_.Release();
}
inline void ReqTaskList::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:satllite.protobuf.task.ReqTaskList.codeSearch)
}

// string noSearch = 3;
inline void ReqTaskList::clear_nosearch() {
  nosearch_.ClearToEmpty();
}
inline const std::string& ReqTaskList::nosearch() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.ReqTaskList.noSearch)
  return _internal_nosearch();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqTaskList::set_nosearch(ArgT0&& arg0, ArgT... args) {
 
 nosearch_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.ReqTaskList.noSearch)
}
inline std::string* ReqTaskList::mutable_nosearch() {
  std::string* _s = _internal_mutable_nosearch();
  // @@protoc_insertion_point(field_mutable:satllite.protobuf.task.ReqTaskList.noSearch)
  return _s;
}
inline const std::string& ReqTaskList::_internal_nosearch() const {
  return nosearch_.Get();
}
inline void ReqTaskList::_internal_set_nosearch(const std::string& value) {
  
  nosearch_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqTaskList::_internal_mutable_nosearch() {
  
  return nosearch_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqTaskList::release_nosearch() {
  // @@protoc_insertion_point(field_release:satllite.protobuf.task.ReqTaskList.noSearch)
  return nosearch_.Release();
}
inline void ReqTaskList::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:satllite.protobuf.task.ReqTaskList.noSearch)
}

// .satllite.protobuf.task.TaskGrade grade = 4;
inline void ReqTaskList::clear_grade() {
  grade_ = 0;
}
inline ::satllite::protobuf::task::TaskGrade ReqTaskList::_internal_grade() const {
  return static_cast< ::satllite::protobuf::task::TaskGrade >(grade_);
}
inline ::satllite::protobuf::task::TaskGrade ReqTaskList::grade() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.ReqTaskList.grade)
  return _internal_grade();
}
inline void ReqTaskList::_internal_set_grade(::satllite::protobuf::task::TaskGrade value) {
  
  grade_ = value;
}
inline void ReqTaskList::set_grade(::satllite::protobuf::task::TaskGrade value) {
  _internal_set_grade(value);
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.ReqTaskList.grade)
}

// string start = 5;
inline void ReqTaskList::clear_start() {
  start_.ClearToEmpty();
}
inline const std::string& ReqTaskList::start() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.ReqTaskList.start)
  return _internal_start();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqTaskList::set_start(ArgT0&& arg0, ArgT... args) {
 
 start_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.ReqTaskList.start)
}
inline std::string* ReqTaskList::mutable_start() {
  std::string* _s = _internal_mutable_start();
  // @@protoc_insertion_point(field_mutable:satllite.protobuf.task.ReqTaskList.start)
  return _s;
}
inline const std::string& ReqTaskList::_internal_start() const {
  return start_.Get();
}
inline void ReqTaskList::_internal_set_start(const std::string& value) {
  
  start_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqTaskList::_internal_mutable_start() {
  
  return start_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqTaskList::release_start() {
  // @@protoc_insertion_point(field_release:satllite.protobuf.task.ReqTaskList.start)
  return start_.Release();
}
inline void ReqTaskList::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:satllite.protobuf.task.ReqTaskList.start)
}

// string end = 6;
inline void ReqTaskList::clear_end() {
  end_.ClearToEmpty();
}
inline const std::string& ReqTaskList::end() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.ReqTaskList.end)
  return _internal_end();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqTaskList::set_end(ArgT0&& arg0, ArgT... args) {
 
 end_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.ReqTaskList.end)
}
inline std::string* ReqTaskList::mutable_end() {
  std::string* _s = _internal_mutable_end();
  // @@protoc_insertion_point(field_mutable:satllite.protobuf.task.ReqTaskList.end)
  return _s;
}
inline const std::string& ReqTaskList::_internal_end() const {
  return end_.Get();
}
inline void ReqTaskList::_internal_set_end(const std::string& value) {
  
  end_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqTaskList::_internal_mutable_end() {
  
  return end_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqTaskList::release_end() {
  // @@protoc_insertion_point(field_release:satllite.protobuf.task.ReqTaskList.end)
  return end_.Release();
}
inline void ReqTaskList::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:satllite.protobuf.task.ReqTaskList.end)
}

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

// RetTaskElement

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

// string no = 2;
inline void RetTaskElement::clear_no() {
  no_.ClearToEmpty();
}
inline const std::string& RetTaskElement::no() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskElement.no)
  return _internal_no();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskElement::set_no(ArgT0&& arg0, ArgT... args) {
 
 no_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskElement.no)
}
inline std::string* RetTaskElement::mutable_no() {
  std::string* _s = _internal_mutable_no();
  // @@protoc_insertion_point(field_mutable:satllite.protobuf.task.RetTaskElement.no)
  return _s;
}
inline const std::string& RetTaskElement::_internal_no() const {
  return no_.Get();
}
inline void RetTaskElement::_internal_set_no(const std::string& value) {
  
  no_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskElement::_internal_mutable_no() {
  
  return no_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskElement::release_no() {
  // @@protoc_insertion_point(field_release:satllite.protobuf.task.RetTaskElement.no)
  return no_.Release();
}
inline void RetTaskElement::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:satllite.protobuf.task.RetTaskElement.no)
}

// string sId = 3;
inline void RetTaskElement::clear_sid() {
  sid_.ClearToEmpty();
}
inline const std::string& RetTaskElement::sid() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskElement.sId)
  return _internal_sid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskElement::set_sid(ArgT0&& arg0, ArgT... args) {
 
 sid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskElement.sId)
}
inline std::string* RetTaskElement::mutable_sid() {
  std::string* _s = _internal_mutable_sid();
  // @@protoc_insertion_point(field_mutable:satllite.protobuf.task.RetTaskElement.sId)
  return _s;
}
inline const std::string& RetTaskElement::_internal_sid() const {
  return sid_.Get();
}
inline void RetTaskElement::_internal_set_sid(const std::string& value) {
  
  sid_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskElement::_internal_mutable_sid() {
  
  return sid_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskElement::release_sid() {
  // @@protoc_insertion_point(field_release:satllite.protobuf.task.RetTaskElement.sId)
  return sid_.Release();
}
inline void RetTaskElement::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:satllite.protobuf.task.RetTaskElement.sId)
}

// string sNorad = 4;
inline void RetTaskElement::clear_snorad() {
  snorad_.ClearToEmpty();
}
inline const std::string& RetTaskElement::snorad() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskElement.sNorad)
  return _internal_snorad();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskElement::set_snorad(ArgT0&& arg0, ArgT... args) {
 
 snorad_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskElement.sNorad)
}
inline std::string* RetTaskElement::mutable_snorad() {
  std::string* _s = _internal_mutable_snorad();
  // @@protoc_insertion_point(field_mutable:satllite.protobuf.task.RetTaskElement.sNorad)
  return _s;
}
inline const std::string& RetTaskElement::_internal_snorad() const {
  return snorad_.Get();
}
inline void RetTaskElement::_internal_set_snorad(const std::string& value) {
  
  snorad_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskElement::_internal_mutable_snorad() {
  
  return snorad_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskElement::release_snorad() {
  // @@protoc_insertion_point(field_release:satllite.protobuf.task.RetTaskElement.sNorad)
  return snorad_.Release();
}
inline void RetTaskElement::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:satllite.protobuf.task.RetTaskElement.sNorad)
}

// string sName = 5;
inline void RetTaskElement::clear_sname() {
  sname_.ClearToEmpty();
}
inline const std::string& RetTaskElement::sname() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskElement.sName)
  return _internal_sname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskElement::set_sname(ArgT0&& arg0, ArgT... args) {
 
 sname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskElement.sName)
}
inline std::string* RetTaskElement::mutable_sname() {
  std::string* _s = _internal_mutable_sname();
  // @@protoc_insertion_point(field_mutable:satllite.protobuf.task.RetTaskElement.sName)
  return _s;
}
inline const std::string& RetTaskElement::_internal_sname() const {
  return sname_.Get();
}
inline void RetTaskElement::_internal_set_sname(const std::string& value) {
  
  sname_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskElement::_internal_mutable_sname() {
  
  return sname_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskElement::release_sname() {
  // @@protoc_insertion_point(field_release:satllite.protobuf.task.RetTaskElement.sName)
  return sname_.Release();
}
inline void RetTaskElement::set_allocated_sname(std::string* sname) {
  if (sname != nullptr) {
    
  } else {
    
  }
  sname_.SetAllocated(sname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (sname_.IsDefault()) {
    sname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:satllite.protobuf.task.RetTaskElement.sName)
}

// int32 circle = 6;
inline void RetTaskElement::clear_circle() {
  circle_ = 0;
}
inline int32_t RetTaskElement::_internal_circle() const {
  return circle_;
}
inline int32_t RetTaskElement::circle() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskElement.circle)
  return _internal_circle();
}
inline void RetTaskElement::_internal_set_circle(int32_t value) {
  
  circle_ = value;
}
inline void RetTaskElement::set_circle(int32_t value) {
  _internal_set_circle(value);
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskElement.circle)
}

// string startDt = 7;
inline void RetTaskElement::clear_startdt() {
  startdt_.ClearToEmpty();
}
inline const std::string& RetTaskElement::startdt() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskElement.startDt)
  return _internal_startdt();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskElement::set_startdt(ArgT0&& arg0, ArgT... args) {
 
 startdt_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskElement.startDt)
}
inline std::string* RetTaskElement::mutable_startdt() {
  std::string* _s = _internal_mutable_startdt();
  // @@protoc_insertion_point(field_mutable:satllite.protobuf.task.RetTaskElement.startDt)
  return _s;
}
inline const std::string& RetTaskElement::_internal_startdt() const {
  return startdt_.Get();
}
inline void RetTaskElement::_internal_set_startdt(const std::string& value) {
  
  startdt_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskElement::_internal_mutable_startdt() {
  
  return startdt_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskElement::release_startdt() {
  // @@protoc_insertion_point(field_release:satllite.protobuf.task.RetTaskElement.startDt)
  return startdt_.Release();
}
inline void RetTaskElement::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:satllite.protobuf.task.RetTaskElement.startDt)
}

// string endDt = 8;
inline void RetTaskElement::clear_enddt() {
  enddt_.ClearToEmpty();
}
inline const std::string& RetTaskElement::enddt() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskElement.endDt)
  return _internal_enddt();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskElement::set_enddt(ArgT0&& arg0, ArgT... args) {
 
 enddt_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskElement.endDt)
}
inline std::string* RetTaskElement::mutable_enddt() {
  std::string* _s = _internal_mutable_enddt();
  // @@protoc_insertion_point(field_mutable:satllite.protobuf.task.RetTaskElement.endDt)
  return _s;
}
inline const std::string& RetTaskElement::_internal_enddt() const {
  return enddt_.Get();
}
inline void RetTaskElement::_internal_set_enddt(const std::string& value) {
  
  enddt_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskElement::_internal_mutable_enddt() {
  
  return enddt_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskElement::release_enddt() {
  // @@protoc_insertion_point(field_release:satllite.protobuf.task.RetTaskElement.endDt)
  return enddt_.Release();
}
inline void RetTaskElement::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:satllite.protobuf.task.RetTaskElement.endDt)
}

// int32 duration = 9;
inline void RetTaskElement::clear_duration() {
  duration_ = 0;
}
inline int32_t RetTaskElement::_internal_duration() const {
  return duration_;
}
inline int32_t RetTaskElement::duration() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskElement.duration)
  return _internal_duration();
}
inline void RetTaskElement::_internal_set_duration(int32_t value) {
  
  duration_ = value;
}
inline void RetTaskElement::set_duration(int32_t value) {
  _internal_set_duration(value);
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskElement.duration)
}

// .satllite.protobuf.task.TaskStatus status = 10;
inline void RetTaskElement::clear_status() {
  status_ = 0;
}
inline ::satllite::protobuf::task::TaskStatus RetTaskElement::_internal_status() const {
  return static_cast< ::satllite::protobuf::task::TaskStatus >(status_);
}
inline ::satllite::protobuf::task::TaskStatus RetTaskElement::status() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskElement.status)
  return _internal_status();
}
inline void RetTaskElement::_internal_set_status(::satllite::protobuf::task::TaskStatus value) {
  
  status_ = value;
}
inline void RetTaskElement::set_status(::satllite::protobuf::task::TaskStatus value) {
  _internal_set_status(value);
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskElement.status)
}

// double startAziAngle = 11;
inline void RetTaskElement::clear_startaziangle() {
  startaziangle_ = 0;
}
inline double RetTaskElement::_internal_startaziangle() const {
  return startaziangle_;
}
inline double RetTaskElement::startaziangle() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskElement.startAziAngle)
  return _internal_startaziangle();
}
inline void RetTaskElement::_internal_set_startaziangle(double value) {
  
  startaziangle_ = value;
}
inline void RetTaskElement::set_startaziangle(double value) {
  _internal_set_startaziangle(value);
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskElement.startAziAngle)
}

// double endAziAngle = 12;
inline void RetTaskElement::clear_endaziangle() {
  endaziangle_ = 0;
}
inline double RetTaskElement::_internal_endaziangle() const {
  return endaziangle_;
}
inline double RetTaskElement::endaziangle() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskElement.endAziAngle)
  return _internal_endaziangle();
}
inline void RetTaskElement::_internal_set_endaziangle(double value) {
  
  endaziangle_ = value;
}
inline void RetTaskElement::set_endaziangle(double value) {
  _internal_set_endaziangle(value);
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskElement.endAziAngle)
}

// double startEleAngle = 13;
inline void RetTaskElement::clear_starteleangle() {
  starteleangle_ = 0;
}
inline double RetTaskElement::_internal_starteleangle() const {
  return starteleangle_;
}
inline double RetTaskElement::starteleangle() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskElement.startEleAngle)
  return _internal_starteleangle();
}
inline void RetTaskElement::_internal_set_starteleangle(double value) {
  
  starteleangle_ = value;
}
inline void RetTaskElement::set_starteleangle(double value) {
  _internal_set_starteleangle(value);
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskElement.startEleAngle)
}

// double maxEleAngle = 14;
inline void RetTaskElement::clear_maxeleangle() {
  maxeleangle_ = 0;
}
inline double RetTaskElement::_internal_maxeleangle() const {
  return maxeleangle_;
}
inline double RetTaskElement::maxeleangle() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskElement.maxEleAngle)
  return _internal_maxeleangle();
}
inline void RetTaskElement::_internal_set_maxeleangle(double value) {
  
  maxeleangle_ = value;
}
inline void RetTaskElement::set_maxeleangle(double value) {
  _internal_set_maxeleangle(value);
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskElement.maxEleAngle)
}

// double minDist = 15;
inline void RetTaskElement::clear_mindist() {
  mindist_ = 0;
}
inline double RetTaskElement::_internal_mindist() const {
  return mindist_;
}
inline double RetTaskElement::mindist() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskElement.minDist)
  return _internal_mindist();
}
inline void RetTaskElement::_internal_set_mindist(double value) {
  
  mindist_ = value;
}
inline void RetTaskElement::set_mindist(double value) {
  _internal_set_mindist(value);
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskElement.minDist)
}

// double maxDist = 16;
inline void RetTaskElement::clear_maxdist() {
  maxdist_ = 0;
}
inline double RetTaskElement::_internal_maxdist() const {
  return maxdist_;
}
inline double RetTaskElement::maxdist() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskElement.maxDist)
  return _internal_maxdist();
}
inline void RetTaskElement::_internal_set_maxdist(double value) {
  
  maxdist_ = value;
}
inline void RetTaskElement::set_maxdist(double value) {
  _internal_set_maxdist(value);
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskElement.maxDist)
}

// bool conflict = 17;
inline void RetTaskElement::clear_conflict() {
  conflict_ = false;
}
inline bool RetTaskElement::_internal_conflict() const {
  return conflict_;
}
inline bool RetTaskElement::conflict() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskElement.conflict)
  return _internal_conflict();
}
inline void RetTaskElement::_internal_set_conflict(bool value) {
  
  conflict_ = value;
}
inline void RetTaskElement::set_conflict(bool value) {
  _internal_set_conflict(value);
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskElement.conflict)
}

// bool shortage = 18;
inline void RetTaskElement::clear_shortage() {
  shortage_ = false;
}
inline bool RetTaskElement::_internal_shortage() const {
  return shortage_;
}
inline bool RetTaskElement::shortage() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskElement.shortage)
  return _internal_shortage();
}
inline void RetTaskElement::_internal_set_shortage(bool value) {
  
  shortage_ = value;
}
inline void RetTaskElement::set_shortage(bool value) {
  _internal_set_shortage(value);
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskElement.shortage)
}

// .satllite.protobuf.task.TaskGrade grade = 19;
inline void RetTaskElement::clear_grade() {
  grade_ = 0;
}
inline ::satllite::protobuf::task::TaskGrade RetTaskElement::_internal_grade() const {
  return static_cast< ::satllite::protobuf::task::TaskGrade >(grade_);
}
inline ::satllite::protobuf::task::TaskGrade RetTaskElement::grade() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskElement.grade)
  return _internal_grade();
}
inline void RetTaskElement::_internal_set_grade(::satllite::protobuf::task::TaskGrade value) {
  
  grade_ = value;
}
inline void RetTaskElement::set_grade(::satllite::protobuf::task::TaskGrade value) {
  _internal_set_grade(value);
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskElement.grade)
}

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

// string siteName = 21;
inline void RetTaskElement::clear_sitename() {
  sitename_.ClearToEmpty();
}
inline const std::string& RetTaskElement::sitename() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskElement.siteName)
  return _internal_sitename();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskElement::set_sitename(ArgT0&& arg0, ArgT... args) {
 
 sitename_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskElement.siteName)
}
inline std::string* RetTaskElement::mutable_sitename() {
  std::string* _s = _internal_mutable_sitename();
  // @@protoc_insertion_point(field_mutable:satllite.protobuf.task.RetTaskElement.siteName)
  return _s;
}
inline const std::string& RetTaskElement::_internal_sitename() const {
  return sitename_.Get();
}
inline void RetTaskElement::_internal_set_sitename(const std::string& value) {
  
  sitename_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskElement::_internal_mutable_sitename() {
  
  return sitename_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskElement::release_sitename() {
  // @@protoc_insertion_point(field_release:satllite.protobuf.task.RetTaskElement.siteName)
  return sitename_.Release();
}
inline void RetTaskElement::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:satllite.protobuf.task.RetTaskElement.siteName)
}

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

// ReqTaskDel

// repeated int32 id = 1;
inline int ReqTaskDel::_internal_id_size() const {
  return id_.size();
}
inline int ReqTaskDel::id_size() const {
  return _internal_id_size();
}
inline void ReqTaskDel::clear_id() {
  id_.Clear();
}
inline int32_t ReqTaskDel::_internal_id(int index) const {
  return id_.Get(index);
}
inline int32_t ReqTaskDel::id(int index) const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.ReqTaskDel.id)
  return _internal_id(index);
}
inline void ReqTaskDel::set_id(int index, int32_t value) {
  id_.Set(index, value);
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.ReqTaskDel.id)
}
inline void ReqTaskDel::_internal_add_id(int32_t value) {
  id_.Add(value);
}
inline void ReqTaskDel::add_id(int32_t value) {
  _internal_add_id(value);
  // @@protoc_insertion_point(field_add:satllite.protobuf.task.ReqTaskDel.id)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
ReqTaskDel::_internal_id() const {
  return id_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
ReqTaskDel::id() const {
  // @@protoc_insertion_point(field_list:satllite.protobuf.task.ReqTaskDel.id)
  return _internal_id();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
ReqTaskDel::_internal_mutable_id() {
  return &id_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
ReqTaskDel::mutable_id() {
  // @@protoc_insertion_point(field_mutable_list:satllite.protobuf.task.ReqTaskDel.id)
  return _internal_mutable_id();
}

// int32 uid = 2;
inline void ReqTaskDel::clear_uid() {
  uid_ = 0;
}
inline int32_t ReqTaskDel::_internal_uid() const {
  return uid_;
}
inline int32_t ReqTaskDel::uid() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.ReqTaskDel.uid)
  return _internal_uid();
}
inline void ReqTaskDel::_internal_set_uid(int32_t value) {
  
  uid_ = value;
}
inline void ReqTaskDel::set_uid(int32_t value) {
  _internal_set_uid(value);
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.ReqTaskDel.uid)
}

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

// ReqTaskDetailDat

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

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

// RetTaskDat

// string date = 1;
inline void RetTaskDat::clear_date() {
  date_.ClearToEmpty();
}
inline const std::string& RetTaskDat::date() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskDat.date)
  return _internal_date();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskDat::set_date(ArgT0&& arg0, ArgT... args) {
 
 date_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskDat.date)
}
inline std::string* RetTaskDat::mutable_date() {
  std::string* _s = _internal_mutable_date();
  // @@protoc_insertion_point(field_mutable:satllite.protobuf.task.RetTaskDat.date)
  return _s;
}
inline const std::string& RetTaskDat::_internal_date() const {
  return date_.Get();
}
inline void RetTaskDat::_internal_set_date(const std::string& value) {
  
  date_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskDat::_internal_mutable_date() {
  
  return date_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskDat::release_date() {
  // @@protoc_insertion_point(field_release:satllite.protobuf.task.RetTaskDat.date)
  return date_.Release();
}
inline void RetTaskDat::set_allocated_date(std::string* date) {
  if (date != nullptr) {
    
  } else {
    
  }
  date_.SetAllocated(date, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (date_.IsDefault()) {
    date_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:satllite.protobuf.task.RetTaskDat.date)
}

// string time = 2;
inline void RetTaskDat::clear_time() {
  time_.ClearToEmpty();
}
inline const std::string& RetTaskDat::time() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskDat.time)
  return _internal_time();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskDat::set_time(ArgT0&& arg0, ArgT... args) {
 
 time_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskDat.time)
}
inline std::string* RetTaskDat::mutable_time() {
  std::string* _s = _internal_mutable_time();
  // @@protoc_insertion_point(field_mutable:satllite.protobuf.task.RetTaskDat.time)
  return _s;
}
inline const std::string& RetTaskDat::_internal_time() const {
  return time_.Get();
}
inline void RetTaskDat::_internal_set_time(const std::string& value) {
  
  time_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskDat::_internal_mutable_time() {
  
  return time_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskDat::release_time() {
  // @@protoc_insertion_point(field_release:satllite.protobuf.task.RetTaskDat.time)
  return time_.Release();
}
inline void RetTaskDat::set_allocated_time(std::string* time) {
  if (time != nullptr) {
    
  } else {
    
  }
  time_.SetAllocated(time, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (time_.IsDefault()) {
    time_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:satllite.protobuf.task.RetTaskDat.time)
}

// string aziAngle = 3;
inline void RetTaskDat::clear_aziangle() {
  aziangle_.ClearToEmpty();
}
inline const std::string& RetTaskDat::aziangle() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskDat.aziAngle)
  return _internal_aziangle();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskDat::set_aziangle(ArgT0&& arg0, ArgT... args) {
 
 aziangle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskDat.aziAngle)
}
inline std::string* RetTaskDat::mutable_aziangle() {
  std::string* _s = _internal_mutable_aziangle();
  // @@protoc_insertion_point(field_mutable:satllite.protobuf.task.RetTaskDat.aziAngle)
  return _s;
}
inline const std::string& RetTaskDat::_internal_aziangle() const {
  return aziangle_.Get();
}
inline void RetTaskDat::_internal_set_aziangle(const std::string& value) {
  
  aziangle_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskDat::_internal_mutable_aziangle() {
  
  return aziangle_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskDat::release_aziangle() {
  // @@protoc_insertion_point(field_release:satllite.protobuf.task.RetTaskDat.aziAngle)
  return aziangle_.Release();
}
inline void RetTaskDat::set_allocated_aziangle(std::string* aziangle) {
  if (aziangle != nullptr) {
    
  } else {
    
  }
  aziangle_.SetAllocated(aziangle, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (aziangle_.IsDefault()) {
    aziangle_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:satllite.protobuf.task.RetTaskDat.aziAngle)
}

// string eleAngle = 4;
inline void RetTaskDat::clear_eleangle() {
  eleangle_.ClearToEmpty();
}
inline const std::string& RetTaskDat::eleangle() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskDat.eleAngle)
  return _internal_eleangle();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskDat::set_eleangle(ArgT0&& arg0, ArgT... args) {
 
 eleangle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskDat.eleAngle)
}
inline std::string* RetTaskDat::mutable_eleangle() {
  std::string* _s = _internal_mutable_eleangle();
  // @@protoc_insertion_point(field_mutable:satllite.protobuf.task.RetTaskDat.eleAngle)
  return _s;
}
inline const std::string& RetTaskDat::_internal_eleangle() const {
  return eleangle_.Get();
}
inline void RetTaskDat::_internal_set_eleangle(const std::string& value) {
  
  eleangle_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskDat::_internal_mutable_eleangle() {
  
  return eleangle_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskDat::release_eleangle() {
  // @@protoc_insertion_point(field_release:satllite.protobuf.task.RetTaskDat.eleAngle)
  return eleangle_.Release();
}
inline void RetTaskDat::set_allocated_eleangle(std::string* eleangle) {
  if (eleangle != nullptr) {
    
  } else {
    
  }
  eleangle_.SetAllocated(eleangle, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (eleangle_.IsDefault()) {
    eleangle_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:satllite.protobuf.task.RetTaskDat.eleAngle)
}

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

// ReqTaskDetailPoint

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

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

// RetTaskPoint

// string date = 1;
inline void RetTaskPoint::clear_date() {
  date_.ClearToEmpty();
}
inline const std::string& RetTaskPoint::date() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskPoint.date)
  return _internal_date();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskPoint::set_date(ArgT0&& arg0, ArgT... args) {
 
 date_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskPoint.date)
}
inline std::string* RetTaskPoint::mutable_date() {
  std::string* _s = _internal_mutable_date();
  // @@protoc_insertion_point(field_mutable:satllite.protobuf.task.RetTaskPoint.date)
  return _s;
}
inline const std::string& RetTaskPoint::_internal_date() const {
  return date_.Get();
}
inline void RetTaskPoint::_internal_set_date(const std::string& value) {
  
  date_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskPoint::_internal_mutable_date() {
  
  return date_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskPoint::release_date() {
  // @@protoc_insertion_point(field_release:satllite.protobuf.task.RetTaskPoint.date)
  return date_.Release();
}
inline void RetTaskPoint::set_allocated_date(std::string* date) {
  if (date != nullptr) {
    
  } else {
    
  }
  date_.SetAllocated(date, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (date_.IsDefault()) {
    date_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:satllite.protobuf.task.RetTaskPoint.date)
}

// string time = 2;
inline void RetTaskPoint::clear_time() {
  time_.ClearToEmpty();
}
inline const std::string& RetTaskPoint::time() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskPoint.time)
  return _internal_time();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskPoint::set_time(ArgT0&& arg0, ArgT... args) {
 
 time_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskPoint.time)
}
inline std::string* RetTaskPoint::mutable_time() {
  std::string* _s = _internal_mutable_time();
  // @@protoc_insertion_point(field_mutable:satllite.protobuf.task.RetTaskPoint.time)
  return _s;
}
inline const std::string& RetTaskPoint::_internal_time() const {
  return time_.Get();
}
inline void RetTaskPoint::_internal_set_time(const std::string& value) {
  
  time_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskPoint::_internal_mutable_time() {
  
  return time_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskPoint::release_time() {
  // @@protoc_insertion_point(field_release:satllite.protobuf.task.RetTaskPoint.time)
  return time_.Release();
}
inline void RetTaskPoint::set_allocated_time(std::string* time) {
  if (time != nullptr) {
    
  } else {
    
  }
  time_.SetAllocated(time, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (time_.IsDefault()) {
    time_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:satllite.protobuf.task.RetTaskPoint.time)
}

// string x = 3;
inline void RetTaskPoint::clear_x() {
  x_.ClearToEmpty();
}
inline const std::string& RetTaskPoint::x() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskPoint.x)
  return _internal_x();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskPoint::set_x(ArgT0&& arg0, ArgT... args) {
 
 x_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskPoint.x)
}
inline std::string* RetTaskPoint::mutable_x() {
  std::string* _s = _internal_mutable_x();
  // @@protoc_insertion_point(field_mutable:satllite.protobuf.task.RetTaskPoint.x)
  return _s;
}
inline const std::string& RetTaskPoint::_internal_x() const {
  return x_.Get();
}
inline void RetTaskPoint::_internal_set_x(const std::string& value) {
  
  x_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskPoint::_internal_mutable_x() {
  
  return x_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskPoint::release_x() {
  // @@protoc_insertion_point(field_release:satllite.protobuf.task.RetTaskPoint.x)
  return x_.Release();
}
inline void RetTaskPoint::set_allocated_x(std::string* x) {
  if (x != nullptr) {
    
  } else {
    
  }
  x_.SetAllocated(x, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (x_.IsDefault()) {
    x_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:satllite.protobuf.task.RetTaskPoint.x)
}

// string y = 4;
inline void RetTaskPoint::clear_y() {
  y_.ClearToEmpty();
}
inline const std::string& RetTaskPoint::y() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskPoint.y)
  return _internal_y();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskPoint::set_y(ArgT0&& arg0, ArgT... args) {
 
 y_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskPoint.y)
}
inline std::string* RetTaskPoint::mutable_y() {
  std::string* _s = _internal_mutable_y();
  // @@protoc_insertion_point(field_mutable:satllite.protobuf.task.RetTaskPoint.y)
  return _s;
}
inline const std::string& RetTaskPoint::_internal_y() const {
  return y_.Get();
}
inline void RetTaskPoint::_internal_set_y(const std::string& value) {
  
  y_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskPoint::_internal_mutable_y() {
  
  return y_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskPoint::release_y() {
  // @@protoc_insertion_point(field_release:satllite.protobuf.task.RetTaskPoint.y)
  return y_.Release();
}
inline void RetTaskPoint::set_allocated_y(std::string* y) {
  if (y != nullptr) {
    
  } else {
    
  }
  y_.SetAllocated(y, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (y_.IsDefault()) {
    y_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:satllite.protobuf.task.RetTaskPoint.y)
}

// string z = 5;
inline void RetTaskPoint::clear_z() {
  z_.ClearToEmpty();
}
inline const std::string& RetTaskPoint::z() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskPoint.z)
  return _internal_z();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskPoint::set_z(ArgT0&& arg0, ArgT... args) {
 
 z_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskPoint.z)
}
inline std::string* RetTaskPoint::mutable_z() {
  std::string* _s = _internal_mutable_z();
  // @@protoc_insertion_point(field_mutable:satllite.protobuf.task.RetTaskPoint.z)
  return _s;
}
inline const std::string& RetTaskPoint::_internal_z() const {
  return z_.Get();
}
inline void RetTaskPoint::_internal_set_z(const std::string& value) {
  
  z_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskPoint::_internal_mutable_z() {
  
  return z_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskPoint::release_z() {
  // @@protoc_insertion_point(field_release:satllite.protobuf.task.RetTaskPoint.z)
  return z_.Release();
}
inline void RetTaskPoint::set_allocated_z(std::string* z) {
  if (z != nullptr) {
    
  } else {
    
  }
  z_.SetAllocated(z, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (z_.IsDefault()) {
    z_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:satllite.protobuf.task.RetTaskPoint.z)
}

// string lat = 6;
inline void RetTaskPoint::clear_lat() {
  lat_.ClearToEmpty();
}
inline const std::string& RetTaskPoint::lat() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskPoint.lat)
  return _internal_lat();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskPoint::set_lat(ArgT0&& arg0, ArgT... args) {
 
 lat_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskPoint.lat)
}
inline std::string* RetTaskPoint::mutable_lat() {
  std::string* _s = _internal_mutable_lat();
  // @@protoc_insertion_point(field_mutable:satllite.protobuf.task.RetTaskPoint.lat)
  return _s;
}
inline const std::string& RetTaskPoint::_internal_lat() const {
  return lat_.Get();
}
inline void RetTaskPoint::_internal_set_lat(const std::string& value) {
  
  lat_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskPoint::_internal_mutable_lat() {
  
  return lat_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskPoint::release_lat() {
  // @@protoc_insertion_point(field_release:satllite.protobuf.task.RetTaskPoint.lat)
  return lat_.Release();
}
inline void RetTaskPoint::set_allocated_lat(std::string* lat) {
  if (lat != nullptr) {
    
  } else {
    
  }
  lat_.SetAllocated(lat, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (lat_.IsDefault()) {
    lat_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:satllite.protobuf.task.RetTaskPoint.lat)
}

// string lon = 7;
inline void RetTaskPoint::clear_lon() {
  lon_.ClearToEmpty();
}
inline const std::string& RetTaskPoint::lon() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskPoint.lon)
  return _internal_lon();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskPoint::set_lon(ArgT0&& arg0, ArgT... args) {
 
 lon_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskPoint.lon)
}
inline std::string* RetTaskPoint::mutable_lon() {
  std::string* _s = _internal_mutable_lon();
  // @@protoc_insertion_point(field_mutable:satllite.protobuf.task.RetTaskPoint.lon)
  return _s;
}
inline const std::string& RetTaskPoint::_internal_lon() const {
  return lon_.Get();
}
inline void RetTaskPoint::_internal_set_lon(const std::string& value) {
  
  lon_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskPoint::_internal_mutable_lon() {
  
  return lon_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskPoint::release_lon() {
  // @@protoc_insertion_point(field_release:satllite.protobuf.task.RetTaskPoint.lon)
  return lon_.Release();
}
inline void RetTaskPoint::set_allocated_lon(std::string* lon) {
  if (lon != nullptr) {
    
  } else {
    
  }
  lon_.SetAllocated(lon, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (lon_.IsDefault()) {
    lon_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:satllite.protobuf.task.RetTaskPoint.lon)
}

// string alt = 8;
inline void RetTaskPoint::clear_alt() {
  alt_.ClearToEmpty();
}
inline const std::string& RetTaskPoint::alt() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.RetTaskPoint.alt)
  return _internal_alt();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetTaskPoint::set_alt(ArgT0&& arg0, ArgT... args) {
 
 alt_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.RetTaskPoint.alt)
}
inline std::string* RetTaskPoint::mutable_alt() {
  std::string* _s = _internal_mutable_alt();
  // @@protoc_insertion_point(field_mutable:satllite.protobuf.task.RetTaskPoint.alt)
  return _s;
}
inline const std::string& RetTaskPoint::_internal_alt() const {
  return alt_.Get();
}
inline void RetTaskPoint::_internal_set_alt(const std::string& value) {
  
  alt_.Set(value, GetArenaForAllocation());
}
inline std::string* RetTaskPoint::_internal_mutable_alt() {
  
  return alt_.Mutable(GetArenaForAllocation());
}
inline std::string* RetTaskPoint::release_alt() {
  // @@protoc_insertion_point(field_release:satllite.protobuf.task.RetTaskPoint.alt)
  return alt_.Release();
}
inline void RetTaskPoint::set_allocated_alt(std::string* alt) {
  if (alt != nullptr) {
    
  } else {
    
  }
  alt_.SetAllocated(alt, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (alt_.IsDefault()) {
    alt_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:satllite.protobuf.task.RetTaskPoint.alt)
}

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

// ReqTaskUpdate

// repeated int32 id = 1;
inline int ReqTaskUpdate::_internal_id_size() const {
  return id_.size();
}
inline int ReqTaskUpdate::id_size() const {
  return _internal_id_size();
}
inline void ReqTaskUpdate::clear_id() {
  id_.Clear();
}
inline int32_t ReqTaskUpdate::_internal_id(int index) const {
  return id_.Get(index);
}
inline int32_t ReqTaskUpdate::id(int index) const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.ReqTaskUpdate.id)
  return _internal_id(index);
}
inline void ReqTaskUpdate::set_id(int index, int32_t value) {
  id_.Set(index, value);
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.ReqTaskUpdate.id)
}
inline void ReqTaskUpdate::_internal_add_id(int32_t value) {
  id_.Add(value);
}
inline void ReqTaskUpdate::add_id(int32_t value) {
  _internal_add_id(value);
  // @@protoc_insertion_point(field_add:satllite.protobuf.task.ReqTaskUpdate.id)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
ReqTaskUpdate::_internal_id() const {
  return id_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
ReqTaskUpdate::id() const {
  // @@protoc_insertion_point(field_list:satllite.protobuf.task.ReqTaskUpdate.id)
  return _internal_id();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
ReqTaskUpdate::_internal_mutable_id() {
  return &id_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
ReqTaskUpdate::mutable_id() {
  // @@protoc_insertion_point(field_mutable_list:satllite.protobuf.task.ReqTaskUpdate.id)
  return _internal_mutable_id();
}

// int32 uid = 2;
inline void ReqTaskUpdate::clear_uid() {
  uid_ = 0;
}
inline int32_t ReqTaskUpdate::_internal_uid() const {
  return uid_;
}
inline int32_t ReqTaskUpdate::uid() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.ReqTaskUpdate.uid)
  return _internal_uid();
}
inline void ReqTaskUpdate::_internal_set_uid(int32_t value) {
  
  uid_ = value;
}
inline void ReqTaskUpdate::set_uid(int32_t value) {
  _internal_set_uid(value);
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.ReqTaskUpdate.uid)
}

// .satllite.protobuf.task.TaskStatus status = 3;
inline void ReqTaskUpdate::clear_status() {
  status_ = 0;
}
inline ::satllite::protobuf::task::TaskStatus ReqTaskUpdate::_internal_status() const {
  return static_cast< ::satllite::protobuf::task::TaskStatus >(status_);
}
inline ::satllite::protobuf::task::TaskStatus ReqTaskUpdate::status() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.ReqTaskUpdate.status)
  return _internal_status();
}
inline void ReqTaskUpdate::_internal_set_status(::satllite::protobuf::task::TaskStatus value) {
  
  status_ = value;
}
inline void ReqTaskUpdate::set_status(::satllite::protobuf::task::TaskStatus value) {
  _internal_set_status(value);
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.ReqTaskUpdate.status)
}

// .satllite.protobuf.task.TaskGrade grade = 4;
inline void ReqTaskUpdate::clear_grade() {
  grade_ = 0;
}
inline ::satllite::protobuf::task::TaskGrade ReqTaskUpdate::_internal_grade() const {
  return static_cast< ::satllite::protobuf::task::TaskGrade >(grade_);
}
inline ::satllite::protobuf::task::TaskGrade ReqTaskUpdate::grade() const {
  // @@protoc_insertion_point(field_get:satllite.protobuf.task.ReqTaskUpdate.grade)
  return _internal_grade();
}
inline void ReqTaskUpdate::_internal_set_grade(::satllite::protobuf::task::TaskGrade value) {
  
  grade_ = value;
}
inline void ReqTaskUpdate::set_grade(::satllite::protobuf::task::TaskGrade value) {
  _internal_set_grade(value);
  // @@protoc_insertion_point(field_set:satllite.protobuf.task.ReqTaskUpdate.grade)
}

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace task
}  // namespace protobuf
}  // namespace satllite

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::satllite::protobuf::task::TaskStatus> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::satllite::protobuf::task::TaskStatus>() {
  return ::satllite::protobuf::task::TaskStatus_descriptor();
}
template <> struct is_proto_enum< ::satllite::protobuf::task::TaskGrade> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::satllite::protobuf::task::TaskGrade>() {
  return ::satllite::protobuf::task::TaskGrade_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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