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

#ifndef GOOGLE_PROTOBUF_INCLUDED_mod_2dsatellite_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_mod_2dsatellite_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_2dsatellite_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_mod_2dsatellite_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_mod_2dsatellite_2eproto;
class ReqSatelliteDel;
struct ReqSatelliteDelDefaultTypeInternal;
extern ReqSatelliteDelDefaultTypeInternal _ReqSatelliteDel_default_instance_;
class ReqSatelliteElementUpdate;
struct ReqSatelliteElementUpdateDefaultTypeInternal;
extern ReqSatelliteElementUpdateDefaultTypeInternal _ReqSatelliteElementUpdate_default_instance_;
class ReqSatelliteFind;
struct ReqSatelliteFindDefaultTypeInternal;
extern ReqSatelliteFindDefaultTypeInternal _ReqSatelliteFind_default_instance_;
class ReqSatelliteInfoUpdate;
struct ReqSatelliteInfoUpdateDefaultTypeInternal;
extern ReqSatelliteInfoUpdateDefaultTypeInternal _ReqSatelliteInfoUpdate_default_instance_;
class ReqSatelliteParamUpdate;
struct ReqSatelliteParamUpdateDefaultTypeInternal;
extern ReqSatelliteParamUpdateDefaultTypeInternal _ReqSatelliteParamUpdate_default_instance_;
class RetSatelliteElement;
struct RetSatelliteElementDefaultTypeInternal;
extern RetSatelliteElementDefaultTypeInternal _RetSatelliteElement_default_instance_;
class RetSatelliteInfoElement;
struct RetSatelliteInfoElementDefaultTypeInternal;
extern RetSatelliteInfoElementDefaultTypeInternal _RetSatelliteInfoElement_default_instance_;
class RetSatelliteParamElement;
struct RetSatelliteParamElementDefaultTypeInternal;
extern RetSatelliteParamElementDefaultTypeInternal _RetSatelliteParamElement_default_instance_;
PROTOBUF_NAMESPACE_OPEN
template<> ::ReqSatelliteDel* Arena::CreateMaybeMessage<::ReqSatelliteDel>(Arena*);
template<> ::ReqSatelliteElementUpdate* Arena::CreateMaybeMessage<::ReqSatelliteElementUpdate>(Arena*);
template<> ::ReqSatelliteFind* Arena::CreateMaybeMessage<::ReqSatelliteFind>(Arena*);
template<> ::ReqSatelliteInfoUpdate* Arena::CreateMaybeMessage<::ReqSatelliteInfoUpdate>(Arena*);
template<> ::ReqSatelliteParamUpdate* Arena::CreateMaybeMessage<::ReqSatelliteParamUpdate>(Arena*);
template<> ::RetSatelliteElement* Arena::CreateMaybeMessage<::RetSatelliteElement>(Arena*);
template<> ::RetSatelliteInfoElement* Arena::CreateMaybeMessage<::RetSatelliteInfoElement>(Arena*);
template<> ::RetSatelliteParamElement* Arena::CreateMaybeMessage<::RetSatelliteParamElement>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

enum ReqSatelliteFind_RetType : int {
  ReqSatelliteFind_RetType_Info = 0,
  ReqSatelliteFind_RetType_Element = 1,
  ReqSatelliteFind_RetType_Param = 2,
  ReqSatelliteFind_RetType_ReqSatelliteFind_RetType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  ReqSatelliteFind_RetType_ReqSatelliteFind_RetType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool ReqSatelliteFind_RetType_IsValid(int value);
constexpr ReqSatelliteFind_RetType ReqSatelliteFind_RetType_RetType_MIN = ReqSatelliteFind_RetType_Info;
constexpr ReqSatelliteFind_RetType ReqSatelliteFind_RetType_RetType_MAX = ReqSatelliteFind_RetType_Param;
constexpr int ReqSatelliteFind_RetType_RetType_ARRAYSIZE = ReqSatelliteFind_RetType_RetType_MAX + 1;

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

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "RetSatelliteElement";
  }
  protected:
  explicit RetSatelliteElement(::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 {
    kNameFieldNumber = 2,
    kNoradFieldNumber = 3,
    kCodeFieldNumber = 4,
    kCodeCenterFieldNumber = 5,
    kDtFieldNumber = 6,
    kUpdateDtFieldNumber = 7,
    kTleFieldNumber = 15,
    kEFieldNumber = 8,
    kAFieldNumber = 9,
    kIFieldNumber = 10,
    kOFieldNumber = 11,
    kWFieldNumber = 12,
    kMFieldNumber = 13,
    kPeriodFieldNumber = 14,
    kIdFieldNumber = 1,
  };
  // string name = 2;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string norad = 3;
  void clear_norad();
  const std::string& norad() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_norad(ArgT0&& arg0, ArgT... args);
  std::string* mutable_norad();
  PROTOBUF_NODISCARD std::string* release_norad();
  void set_allocated_norad(std::string* norad);
  private:
  const std::string& _internal_norad() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_norad(const std::string& value);
  std::string* _internal_mutable_norad();
  public:

  // string code = 4;
  void clear_code();
  const std::string& code() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_code(ArgT0&& arg0, ArgT... args);
  std::string* mutable_code();
  PROTOBUF_NODISCARD std::string* release_code();
  void set_allocated_code(std::string* code);
  private:
  const std::string& _internal_code() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_code(const std::string& value);
  std::string* _internal_mutable_code();
  public:

  // string codeCenter = 5;
  void clear_codecenter();
  const std::string& codecenter() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_codecenter(ArgT0&& arg0, ArgT... args);
  std::string* mutable_codecenter();
  PROTOBUF_NODISCARD std::string* release_codecenter();
  void set_allocated_codecenter(std::string* codecenter);
  private:
  const std::string& _internal_codecenter() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_codecenter(const std::string& value);
  std::string* _internal_mutable_codecenter();
  public:

  // string dt = 6;
  void clear_dt();
  const std::string& dt() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_dt(ArgT0&& arg0, ArgT... args);
  std::string* mutable_dt();
  PROTOBUF_NODISCARD std::string* release_dt();
  void set_allocated_dt(std::string* dt);
  private:
  const std::string& _internal_dt() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_dt(const std::string& value);
  std::string* _internal_mutable_dt();
  public:

  // string updateDt = 7;
  void clear_updatedt();
  const std::string& updatedt() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_updatedt(ArgT0&& arg0, ArgT... args);
  std::string* mutable_updatedt();
  PROTOBUF_NODISCARD std::string* release_updatedt();
  void set_allocated_updatedt(std::string* updatedt);
  private:
  const std::string& _internal_updatedt() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_updatedt(const std::string& value);
  std::string* _internal_mutable_updatedt();
  public:

  // string tle = 15;
  void clear_tle();
  const std::string& tle() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_tle(ArgT0&& arg0, ArgT... args);
  std::string* mutable_tle();
  PROTOBUF_NODISCARD std::string* release_tle();
  void set_allocated_tle(std::string* tle);
  private:
  const std::string& _internal_tle() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_tle(const std::string& value);
  std::string* _internal_mutable_tle();
  public:

  // double e = 8;
  void clear_e();
  double e() const;
  void set_e(double value);
  private:
  double _internal_e() const;
  void _internal_set_e(double value);
  public:

  // double a = 9;
  void clear_a();
  double a() const;
  void set_a(double value);
  private:
  double _internal_a() const;
  void _internal_set_a(double value);
  public:

  // double i = 10;
  void clear_i();
  double i() const;
  void set_i(double value);
  private:
  double _internal_i() const;
  void _internal_set_i(double value);
  public:

  // double o = 11;
  void clear_o();
  double o() const;
  void set_o(double value);
  private:
  double _internal_o() const;
  void _internal_set_o(double value);
  public:

  // double w = 12;
  void clear_w();
  double w() const;
  void set_w(double value);
  private:
  double _internal_w() const;
  void _internal_set_w(double value);
  public:

  // double m = 13;
  void clear_m();
  double m() const;
  void set_m(double value);
  private:
  double _internal_m() const;
  void _internal_set_m(double value);
  public:

  // double period = 14;
  void clear_period();
  double period() const;
  void set_period(double value);
  private:
  double _internal_period() const;
  void _internal_set_period(double value);
  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:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr norad_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr code_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr codecenter_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dt_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr updatedt_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tle_;
  double e_;
  double a_;
  double i_;
  double o_;
  double w_;
  double m_;
  double period_;
  int32_t id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2dsatellite_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ReqSatelliteDel";
  }
  protected:
  explicit ReqSatelliteDel(::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:ReqSatelliteDel)
 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_2dsatellite_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ReqSatelliteElementUpdate";
  }
  protected:
  explicit ReqSatelliteElementUpdate(::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 {
    kTleFieldNumber = 1,
    kUidFieldNumber = 2,
  };
  // string tle = 1;
  void clear_tle();
  const std::string& tle() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_tle(ArgT0&& arg0, ArgT... args);
  std::string* mutable_tle();
  PROTOBUF_NODISCARD std::string* release_tle();
  void set_allocated_tle(std::string* tle);
  private:
  const std::string& _internal_tle() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_tle(const std::string& value);
  std::string* _internal_mutable_tle();
  public:

  // 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:ReqSatelliteElementUpdate)
 private:
  class _Internal;

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

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ReqSatelliteInfoUpdate";
  }
  protected:
  explicit ReqSatelliteInfoUpdate(::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 {
    kCnNameFieldNumber = 3,
    kEnNameFieldNumber = 4,
    kCountryFieldNumber = 5,
    kTypeFieldNumber = 6,
    kPurposeFieldNumber = 7,
    kObserveGradeFieldNumber = 8,
    kLaunchDtFieldNumber = 9,
    kLaunchPlaceFieldNumber = 10,
    kCarrierRocketFieldNumber = 11,
    kAgeLimitFieldNumber = 12,
    kManagerFieldNumber = 13,
    kContractorFieldNumber = 14,
    kPlatformFieldNumber = 15,
    kPayloadFieldNumber = 16,
    kBoosterFieldNumber = 17,
    kPowerFieldNumber = 18,
    kMassFieldNumber = 19,
    kOrbitTypeFieldNumber = 20,
    kRemarkFieldNumber = 21,
    kIdFieldNumber = 1,
    kUidFieldNumber = 2,
  };
  // string cnName = 3;
  void clear_cnname();
  const std::string& cnname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_cnname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_cnname();
  PROTOBUF_NODISCARD std::string* release_cnname();
  void set_allocated_cnname(std::string* cnname);
  private:
  const std::string& _internal_cnname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cnname(const std::string& value);
  std::string* _internal_mutable_cnname();
  public:

  // string enName = 4;
  void clear_enname();
  const std::string& enname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_enname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_enname();
  PROTOBUF_NODISCARD std::string* release_enname();
  void set_allocated_enname(std::string* enname);
  private:
  const std::string& _internal_enname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_enname(const std::string& value);
  std::string* _internal_mutable_enname();
  public:

  // string country = 5;
  void clear_country();
  const std::string& country() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_country(ArgT0&& arg0, ArgT... args);
  std::string* mutable_country();
  PROTOBUF_NODISCARD std::string* release_country();
  void set_allocated_country(std::string* country);
  private:
  const std::string& _internal_country() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_country(const std::string& value);
  std::string* _internal_mutable_country();
  public:

  // string type = 6;
  void clear_type();
  const std::string& type() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_type(ArgT0&& arg0, ArgT... args);
  std::string* mutable_type();
  PROTOBUF_NODISCARD std::string* release_type();
  void set_allocated_type(std::string* type);
  private:
  const std::string& _internal_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type(const std::string& value);
  std::string* _internal_mutable_type();
  public:

  // string purpose = 7;
  void clear_purpose();
  const std::string& purpose() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_purpose(ArgT0&& arg0, ArgT... args);
  std::string* mutable_purpose();
  PROTOBUF_NODISCARD std::string* release_purpose();
  void set_allocated_purpose(std::string* purpose);
  private:
  const std::string& _internal_purpose() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_purpose(const std::string& value);
  std::string* _internal_mutable_purpose();
  public:

  // string observeGrade = 8;
  void clear_observegrade();
  const std::string& observegrade() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_observegrade(ArgT0&& arg0, ArgT... args);
  std::string* mutable_observegrade();
  PROTOBUF_NODISCARD std::string* release_observegrade();
  void set_allocated_observegrade(std::string* observegrade);
  private:
  const std::string& _internal_observegrade() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_observegrade(const std::string& value);
  std::string* _internal_mutable_observegrade();
  public:

  // string launchDt = 9;
  void clear_launchdt();
  const std::string& launchdt() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_launchdt(ArgT0&& arg0, ArgT... args);
  std::string* mutable_launchdt();
  PROTOBUF_NODISCARD std::string* release_launchdt();
  void set_allocated_launchdt(std::string* launchdt);
  private:
  const std::string& _internal_launchdt() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_launchdt(const std::string& value);
  std::string* _internal_mutable_launchdt();
  public:

  // string launchPlace = 10;
  void clear_launchplace();
  const std::string& launchplace() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_launchplace(ArgT0&& arg0, ArgT... args);
  std::string* mutable_launchplace();
  PROTOBUF_NODISCARD std::string* release_launchplace();
  void set_allocated_launchplace(std::string* launchplace);
  private:
  const std::string& _internal_launchplace() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_launchplace(const std::string& value);
  std::string* _internal_mutable_launchplace();
  public:

  // string carrierRocket = 11;
  void clear_carrierrocket();
  const std::string& carrierrocket() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_carrierrocket(ArgT0&& arg0, ArgT... args);
  std::string* mutable_carrierrocket();
  PROTOBUF_NODISCARD std::string* release_carrierrocket();
  void set_allocated_carrierrocket(std::string* carrierrocket);
  private:
  const std::string& _internal_carrierrocket() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_carrierrocket(const std::string& value);
  std::string* _internal_mutable_carrierrocket();
  public:

  // string ageLimit = 12;
  void clear_agelimit();
  const std::string& agelimit() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_agelimit(ArgT0&& arg0, ArgT... args);
  std::string* mutable_agelimit();
  PROTOBUF_NODISCARD std::string* release_agelimit();
  void set_allocated_agelimit(std::string* agelimit);
  private:
  const std::string& _internal_agelimit() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_agelimit(const std::string& value);
  std::string* _internal_mutable_agelimit();
  public:

  // string manager = 13;
  void clear_manager();
  const std::string& manager() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_manager(ArgT0&& arg0, ArgT... args);
  std::string* mutable_manager();
  PROTOBUF_NODISCARD std::string* release_manager();
  void set_allocated_manager(std::string* manager);
  private:
  const std::string& _internal_manager() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_manager(const std::string& value);
  std::string* _internal_mutable_manager();
  public:

  // string contractor = 14;
  void clear_contractor();
  const std::string& contractor() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_contractor(ArgT0&& arg0, ArgT... args);
  std::string* mutable_contractor();
  PROTOBUF_NODISCARD std::string* release_contractor();
  void set_allocated_contractor(std::string* contractor);
  private:
  const std::string& _internal_contractor() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_contractor(const std::string& value);
  std::string* _internal_mutable_contractor();
  public:

  // string platform = 15;
  void clear_platform();
  const std::string& platform() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_platform(ArgT0&& arg0, ArgT... args);
  std::string* mutable_platform();
  PROTOBUF_NODISCARD std::string* release_platform();
  void set_allocated_platform(std::string* platform);
  private:
  const std::string& _internal_platform() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_platform(const std::string& value);
  std::string* _internal_mutable_platform();
  public:

  // string payload = 16;
  void clear_payload();
  const std::string& payload() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_payload(ArgT0&& arg0, ArgT... args);
  std::string* mutable_payload();
  PROTOBUF_NODISCARD std::string* release_payload();
  void set_allocated_payload(std::string* payload);
  private:
  const std::string& _internal_payload() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_payload(const std::string& value);
  std::string* _internal_mutable_payload();
  public:

  // string booster = 17;
  void clear_booster();
  const std::string& booster() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_booster(ArgT0&& arg0, ArgT... args);
  std::string* mutable_booster();
  PROTOBUF_NODISCARD std::string* release_booster();
  void set_allocated_booster(std::string* booster);
  private:
  const std::string& _internal_booster() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_booster(const std::string& value);
  std::string* _internal_mutable_booster();
  public:

  // string power = 18;
  void clear_power();
  const std::string& power() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_power(ArgT0&& arg0, ArgT... args);
  std::string* mutable_power();
  PROTOBUF_NODISCARD std::string* release_power();
  void set_allocated_power(std::string* power);
  private:
  const std::string& _internal_power() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_power(const std::string& value);
  std::string* _internal_mutable_power();
  public:

  // string mass = 19;
  void clear_mass();
  const std::string& mass() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mass(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mass();
  PROTOBUF_NODISCARD std::string* release_mass();
  void set_allocated_mass(std::string* mass);
  private:
  const std::string& _internal_mass() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mass(const std::string& value);
  std::string* _internal_mutable_mass();
  public:

  // string orbitType = 20;
  void clear_orbittype();
  const std::string& orbittype() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_orbittype(ArgT0&& arg0, ArgT... args);
  std::string* mutable_orbittype();
  PROTOBUF_NODISCARD std::string* release_orbittype();
  void set_allocated_orbittype(std::string* orbittype);
  private:
  const std::string& _internal_orbittype() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_orbittype(const std::string& value);
  std::string* _internal_mutable_orbittype();
  public:

  // string remark = 21;
  void clear_remark();
  const std::string& remark() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_remark(ArgT0&& arg0, ArgT... args);
  std::string* mutable_remark();
  PROTOBUF_NODISCARD std::string* release_remark();
  void set_allocated_remark(std::string* remark);
  private:
  const std::string& _internal_remark() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_remark(const std::string& value);
  std::string* _internal_mutable_remark();
  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 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:ReqSatelliteInfoUpdate)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cnname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr enname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr country_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr purpose_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr observegrade_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr launchdt_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr launchplace_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr carrierrocket_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr agelimit_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr manager_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr contractor_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr platform_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr booster_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr power_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mass_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr orbittype_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr remark_;
  int32_t id_;
  int32_t uid_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2dsatellite_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "RetSatelliteInfoElement";
  }
  protected:
  explicit RetSatelliteInfoElement(::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 {
    kCnNameFieldNumber = 3,
    kEnNameFieldNumber = 4,
    kCountryFieldNumber = 5,
    kTypeFieldNumber = 6,
    kPurposeFieldNumber = 7,
    kObserveGradeFieldNumber = 8,
    kLaunchDtFieldNumber = 9,
    kLaunchPlaceFieldNumber = 10,
    kCarrierRocketFieldNumber = 11,
    kAgeLimitFieldNumber = 12,
    kManagerFieldNumber = 13,
    kContractorFieldNumber = 14,
    kPlatformFieldNumber = 15,
    kPayloadFieldNumber = 16,
    kBoosterFieldNumber = 17,
    kPowerFieldNumber = 18,
    kMassFieldNumber = 19,
    kOrbitTypeFieldNumber = 20,
    kRemarkFieldNumber = 21,
    kIdFieldNumber = 1,
  };
  // string cnName = 3;
  void clear_cnname();
  const std::string& cnname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_cnname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_cnname();
  PROTOBUF_NODISCARD std::string* release_cnname();
  void set_allocated_cnname(std::string* cnname);
  private:
  const std::string& _internal_cnname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cnname(const std::string& value);
  std::string* _internal_mutable_cnname();
  public:

  // string enName = 4;
  void clear_enname();
  const std::string& enname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_enname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_enname();
  PROTOBUF_NODISCARD std::string* release_enname();
  void set_allocated_enname(std::string* enname);
  private:
  const std::string& _internal_enname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_enname(const std::string& value);
  std::string* _internal_mutable_enname();
  public:

  // string country = 5;
  void clear_country();
  const std::string& country() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_country(ArgT0&& arg0, ArgT... args);
  std::string* mutable_country();
  PROTOBUF_NODISCARD std::string* release_country();
  void set_allocated_country(std::string* country);
  private:
  const std::string& _internal_country() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_country(const std::string& value);
  std::string* _internal_mutable_country();
  public:

  // string type = 6;
  void clear_type();
  const std::string& type() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_type(ArgT0&& arg0, ArgT... args);
  std::string* mutable_type();
  PROTOBUF_NODISCARD std::string* release_type();
  void set_allocated_type(std::string* type);
  private:
  const std::string& _internal_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type(const std::string& value);
  std::string* _internal_mutable_type();
  public:

  // string purpose = 7;
  void clear_purpose();
  const std::string& purpose() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_purpose(ArgT0&& arg0, ArgT... args);
  std::string* mutable_purpose();
  PROTOBUF_NODISCARD std::string* release_purpose();
  void set_allocated_purpose(std::string* purpose);
  private:
  const std::string& _internal_purpose() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_purpose(const std::string& value);
  std::string* _internal_mutable_purpose();
  public:

  // string observeGrade = 8;
  void clear_observegrade();
  const std::string& observegrade() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_observegrade(ArgT0&& arg0, ArgT... args);
  std::string* mutable_observegrade();
  PROTOBUF_NODISCARD std::string* release_observegrade();
  void set_allocated_observegrade(std::string* observegrade);
  private:
  const std::string& _internal_observegrade() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_observegrade(const std::string& value);
  std::string* _internal_mutable_observegrade();
  public:

  // string launchDt = 9;
  void clear_launchdt();
  const std::string& launchdt() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_launchdt(ArgT0&& arg0, ArgT... args);
  std::string* mutable_launchdt();
  PROTOBUF_NODISCARD std::string* release_launchdt();
  void set_allocated_launchdt(std::string* launchdt);
  private:
  const std::string& _internal_launchdt() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_launchdt(const std::string& value);
  std::string* _internal_mutable_launchdt();
  public:

  // string launchPlace = 10;
  void clear_launchplace();
  const std::string& launchplace() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_launchplace(ArgT0&& arg0, ArgT... args);
  std::string* mutable_launchplace();
  PROTOBUF_NODISCARD std::string* release_launchplace();
  void set_allocated_launchplace(std::string* launchplace);
  private:
  const std::string& _internal_launchplace() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_launchplace(const std::string& value);
  std::string* _internal_mutable_launchplace();
  public:

  // string carrierRocket = 11;
  void clear_carrierrocket();
  const std::string& carrierrocket() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_carrierrocket(ArgT0&& arg0, ArgT... args);
  std::string* mutable_carrierrocket();
  PROTOBUF_NODISCARD std::string* release_carrierrocket();
  void set_allocated_carrierrocket(std::string* carrierrocket);
  private:
  const std::string& _internal_carrierrocket() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_carrierrocket(const std::string& value);
  std::string* _internal_mutable_carrierrocket();
  public:

  // string ageLimit = 12;
  void clear_agelimit();
  const std::string& agelimit() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_agelimit(ArgT0&& arg0, ArgT... args);
  std::string* mutable_agelimit();
  PROTOBUF_NODISCARD std::string* release_agelimit();
  void set_allocated_agelimit(std::string* agelimit);
  private:
  const std::string& _internal_agelimit() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_agelimit(const std::string& value);
  std::string* _internal_mutable_agelimit();
  public:

  // string manager = 13;
  void clear_manager();
  const std::string& manager() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_manager(ArgT0&& arg0, ArgT... args);
  std::string* mutable_manager();
  PROTOBUF_NODISCARD std::string* release_manager();
  void set_allocated_manager(std::string* manager);
  private:
  const std::string& _internal_manager() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_manager(const std::string& value);
  std::string* _internal_mutable_manager();
  public:

  // string contractor = 14;
  void clear_contractor();
  const std::string& contractor() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_contractor(ArgT0&& arg0, ArgT... args);
  std::string* mutable_contractor();
  PROTOBUF_NODISCARD std::string* release_contractor();
  void set_allocated_contractor(std::string* contractor);
  private:
  const std::string& _internal_contractor() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_contractor(const std::string& value);
  std::string* _internal_mutable_contractor();
  public:

  // string platform = 15;
  void clear_platform();
  const std::string& platform() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_platform(ArgT0&& arg0, ArgT... args);
  std::string* mutable_platform();
  PROTOBUF_NODISCARD std::string* release_platform();
  void set_allocated_platform(std::string* platform);
  private:
  const std::string& _internal_platform() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_platform(const std::string& value);
  std::string* _internal_mutable_platform();
  public:

  // string payload = 16;
  void clear_payload();
  const std::string& payload() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_payload(ArgT0&& arg0, ArgT... args);
  std::string* mutable_payload();
  PROTOBUF_NODISCARD std::string* release_payload();
  void set_allocated_payload(std::string* payload);
  private:
  const std::string& _internal_payload() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_payload(const std::string& value);
  std::string* _internal_mutable_payload();
  public:

  // string booster = 17;
  void clear_booster();
  const std::string& booster() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_booster(ArgT0&& arg0, ArgT... args);
  std::string* mutable_booster();
  PROTOBUF_NODISCARD std::string* release_booster();
  void set_allocated_booster(std::string* booster);
  private:
  const std::string& _internal_booster() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_booster(const std::string& value);
  std::string* _internal_mutable_booster();
  public:

  // string power = 18;
  void clear_power();
  const std::string& power() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_power(ArgT0&& arg0, ArgT... args);
  std::string* mutable_power();
  PROTOBUF_NODISCARD std::string* release_power();
  void set_allocated_power(std::string* power);
  private:
  const std::string& _internal_power() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_power(const std::string& value);
  std::string* _internal_mutable_power();
  public:

  // string mass = 19;
  void clear_mass();
  const std::string& mass() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mass(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mass();
  PROTOBUF_NODISCARD std::string* release_mass();
  void set_allocated_mass(std::string* mass);
  private:
  const std::string& _internal_mass() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mass(const std::string& value);
  std::string* _internal_mutable_mass();
  public:

  // string orbitType = 20;
  void clear_orbittype();
  const std::string& orbittype() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_orbittype(ArgT0&& arg0, ArgT... args);
  std::string* mutable_orbittype();
  PROTOBUF_NODISCARD std::string* release_orbittype();
  void set_allocated_orbittype(std::string* orbittype);
  private:
  const std::string& _internal_orbittype() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_orbittype(const std::string& value);
  std::string* _internal_mutable_orbittype();
  public:

  // string remark = 21;
  void clear_remark();
  const std::string& remark() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_remark(ArgT0&& arg0, ArgT... args);
  std::string* mutable_remark();
  PROTOBUF_NODISCARD std::string* release_remark();
  void set_allocated_remark(std::string* remark);
  private:
  const std::string& _internal_remark() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_remark(const std::string& value);
  std::string* _internal_mutable_remark();
  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:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cnname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr enname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr country_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr purpose_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr observegrade_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr launchdt_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr launchplace_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr carrierrocket_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr agelimit_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr manager_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr contractor_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr platform_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr booster_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr power_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mass_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr orbittype_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr remark_;
  int32_t id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2dsatellite_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ReqSatelliteParamUpdate";
  }
  protected:
  explicit ReqSatelliteParamUpdate(::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 {
    kFeedSourceFieldNumber = 3,
    kPolarizationFieldNumber = 4,
    kIdFieldNumber = 1,
    kUidFieldNumber = 2,
    kTrackAcceptFreqFieldNumber = 5,
    kTrackAcceptThresholdFieldNumber = 6,
    kTrackFieldNumber = 7,
    kSampleChannelFieldNumber = 8,
    kRfAttenuationFieldNumber = 9,
    kMidFreqGainFieldNumber = 10,
    kCenterRadioFreqFieldNumber = 11,
    kCheckSignalBoundFieldNumber = 12,
    kSampleRateFieldNumber = 13,
    kCheckSignalRangeFieldNumber = 14,
    kSignalAnalyseTypeFieldNumber = 15,
  };
  // string feedSource = 3;
  void clear_feedsource();
  const std::string& feedsource() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_feedsource(ArgT0&& arg0, ArgT... args);
  std::string* mutable_feedsource();
  PROTOBUF_NODISCARD std::string* release_feedsource();
  void set_allocated_feedsource(std::string* feedsource);
  private:
  const std::string& _internal_feedsource() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_feedsource(const std::string& value);
  std::string* _internal_mutable_feedsource();
  public:

  // string polarization = 4;
  void clear_polarization();
  const std::string& polarization() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_polarization(ArgT0&& arg0, ArgT... args);
  std::string* mutable_polarization();
  PROTOBUF_NODISCARD std::string* release_polarization();
  void set_allocated_polarization(std::string* polarization);
  private:
  const std::string& _internal_polarization() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_polarization(const std::string& value);
  std::string* _internal_mutable_polarization();
  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 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:

  // double trackAcceptFreq = 5;
  void clear_trackacceptfreq();
  double trackacceptfreq() const;
  void set_trackacceptfreq(double value);
  private:
  double _internal_trackacceptfreq() const;
  void _internal_set_trackacceptfreq(double value);
  public:

  // double trackAcceptThreshold = 6;
  void clear_trackacceptthreshold();
  double trackacceptthreshold() const;
  void set_trackacceptthreshold(double value);
  private:
  double _internal_trackacceptthreshold() const;
  void _internal_set_trackacceptthreshold(double value);
  public:

  // bool track = 7;
  void clear_track();
  bool track() const;
  void set_track(bool value);
  private:
  bool _internal_track() const;
  void _internal_set_track(bool value);
  public:

  // int32 sampleChannel = 8;
  void clear_samplechannel();
  int32_t samplechannel() const;
  void set_samplechannel(int32_t value);
  private:
  int32_t _internal_samplechannel() const;
  void _internal_set_samplechannel(int32_t value);
  public:

  // int32 rfAttenuation = 9;
  void clear_rfattenuation();
  int32_t rfattenuation() const;
  void set_rfattenuation(int32_t value);
  private:
  int32_t _internal_rfattenuation() const;
  void _internal_set_rfattenuation(int32_t value);
  public:

  // int32 midFreqGain = 10;
  void clear_midfreqgain();
  int32_t midfreqgain() const;
  void set_midfreqgain(int32_t value);
  private:
  int32_t _internal_midfreqgain() const;
  void _internal_set_midfreqgain(int32_t value);
  public:

  // double centerRadioFreq = 11;
  void clear_centerradiofreq();
  double centerradiofreq() const;
  void set_centerradiofreq(double value);
  private:
  double _internal_centerradiofreq() const;
  void _internal_set_centerradiofreq(double value);
  public:

  // int32 checkSignalBound = 12;
  void clear_checksignalbound();
  int32_t checksignalbound() const;
  void set_checksignalbound(int32_t value);
  private:
  int32_t _internal_checksignalbound() const;
  void _internal_set_checksignalbound(int32_t value);
  public:

  // int32 sampleRate = 13;
  void clear_samplerate();
  int32_t samplerate() const;
  void set_samplerate(int32_t value);
  private:
  int32_t _internal_samplerate() const;
  void _internal_set_samplerate(int32_t value);
  public:

  // int32 checkSignalRange = 14;
  void clear_checksignalrange();
  int32_t checksignalrange() const;
  void set_checksignalrange(int32_t value);
  private:
  int32_t _internal_checksignalrange() const;
  void _internal_set_checksignalrange(int32_t value);
  public:

  // int32 signalAnalyseType = 15;
  void clear_signalanalysetype();
  int32_t signalanalysetype() const;
  void set_signalanalysetype(int32_t value);
  private:
  int32_t _internal_signalanalysetype() const;
  void _internal_set_signalanalysetype(int32_t value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr feedsource_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr polarization_;
  int32_t id_;
  int32_t uid_;
  double trackacceptfreq_;
  double trackacceptthreshold_;
  bool track_;
  int32_t samplechannel_;
  int32_t rfattenuation_;
  int32_t midfreqgain_;
  double centerradiofreq_;
  int32_t checksignalbound_;
  int32_t samplerate_;
  int32_t checksignalrange_;
  int32_t signalanalysetype_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2dsatellite_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "RetSatelliteParamElement";
  }
  protected:
  explicit RetSatelliteParamElement(::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 {
    kFeedSourceFieldNumber = 3,
    kPolarizationFieldNumber = 4,
    kIdFieldNumber = 1,
    kTrackFieldNumber = 7,
    kTrackAcceptFreqFieldNumber = 5,
    kTrackAcceptThresholdFieldNumber = 6,
    kSampleChannelFieldNumber = 8,
    kRfAttenuationFieldNumber = 9,
    kCenterRadioFreqFieldNumber = 11,
    kMidFreqGainFieldNumber = 10,
    kCheckSignalBoundFieldNumber = 12,
    kSampleRateFieldNumber = 13,
    kCheckSignalRangeFieldNumber = 14,
    kSignalAnalyseTypeFieldNumber = 15,
  };
  // string feedSource = 3;
  void clear_feedsource();
  const std::string& feedsource() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_feedsource(ArgT0&& arg0, ArgT... args);
  std::string* mutable_feedsource();
  PROTOBUF_NODISCARD std::string* release_feedsource();
  void set_allocated_feedsource(std::string* feedsource);
  private:
  const std::string& _internal_feedsource() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_feedsource(const std::string& value);
  std::string* _internal_mutable_feedsource();
  public:

  // string polarization = 4;
  void clear_polarization();
  const std::string& polarization() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_polarization(ArgT0&& arg0, ArgT... args);
  std::string* mutable_polarization();
  PROTOBUF_NODISCARD std::string* release_polarization();
  void set_allocated_polarization(std::string* polarization);
  private:
  const std::string& _internal_polarization() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_polarization(const std::string& value);
  std::string* _internal_mutable_polarization();
  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:

  // bool track = 7;
  void clear_track();
  bool track() const;
  void set_track(bool value);
  private:
  bool _internal_track() const;
  void _internal_set_track(bool value);
  public:

  // double trackAcceptFreq = 5;
  void clear_trackacceptfreq();
  double trackacceptfreq() const;
  void set_trackacceptfreq(double value);
  private:
  double _internal_trackacceptfreq() const;
  void _internal_set_trackacceptfreq(double value);
  public:

  // double trackAcceptThreshold = 6;
  void clear_trackacceptthreshold();
  double trackacceptthreshold() const;
  void set_trackacceptthreshold(double value);
  private:
  double _internal_trackacceptthreshold() const;
  void _internal_set_trackacceptthreshold(double value);
  public:

  // int32 sampleChannel = 8;
  void clear_samplechannel();
  int32_t samplechannel() const;
  void set_samplechannel(int32_t value);
  private:
  int32_t _internal_samplechannel() const;
  void _internal_set_samplechannel(int32_t value);
  public:

  // int32 rfAttenuation = 9;
  void clear_rfattenuation();
  int32_t rfattenuation() const;
  void set_rfattenuation(int32_t value);
  private:
  int32_t _internal_rfattenuation() const;
  void _internal_set_rfattenuation(int32_t value);
  public:

  // double centerRadioFreq = 11;
  void clear_centerradiofreq();
  double centerradiofreq() const;
  void set_centerradiofreq(double value);
  private:
  double _internal_centerradiofreq() const;
  void _internal_set_centerradiofreq(double value);
  public:

  // int32 midFreqGain = 10;
  void clear_midfreqgain();
  int32_t midfreqgain() const;
  void set_midfreqgain(int32_t value);
  private:
  int32_t _internal_midfreqgain() const;
  void _internal_set_midfreqgain(int32_t value);
  public:

  // int32 checkSignalBound = 12;
  void clear_checksignalbound();
  int32_t checksignalbound() const;
  void set_checksignalbound(int32_t value);
  private:
  int32_t _internal_checksignalbound() const;
  void _internal_set_checksignalbound(int32_t value);
  public:

  // int32 sampleRate = 13;
  void clear_samplerate();
  int32_t samplerate() const;
  void set_samplerate(int32_t value);
  private:
  int32_t _internal_samplerate() const;
  void _internal_set_samplerate(int32_t value);
  public:

  // int32 checkSignalRange = 14;
  void clear_checksignalrange();
  int32_t checksignalrange() const;
  void set_checksignalrange(int32_t value);
  private:
  int32_t _internal_checksignalrange() const;
  void _internal_set_checksignalrange(int32_t value);
  public:

  // int32 signalAnalyseType = 15;
  void clear_signalanalysetype();
  int32_t signalanalysetype() const;
  void set_signalanalysetype(int32_t value);
  private:
  int32_t _internal_signalanalysetype() const;
  void _internal_set_signalanalysetype(int32_t value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr feedsource_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr polarization_;
  int32_t id_;
  bool track_;
  double trackacceptfreq_;
  double trackacceptthreshold_;
  int32_t samplechannel_;
  int32_t rfattenuation_;
  double centerradiofreq_;
  int32_t midfreqgain_;
  int32_t checksignalbound_;
  int32_t samplerate_;
  int32_t checksignalrange_;
  int32_t signalanalysetype_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2dsatellite_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ReqSatelliteFind";
  }
  protected:
  explicit ReqSatelliteFind(::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 ----------------------------------------------------

  typedef ReqSatelliteFind_RetType RetType;
  static constexpr RetType Info =
    ReqSatelliteFind_RetType_Info;
  static constexpr RetType Element =
    ReqSatelliteFind_RetType_Element;
  static constexpr RetType Param =
    ReqSatelliteFind_RetType_Param;
  static inline bool RetType_IsValid(int value) {
    return ReqSatelliteFind_RetType_IsValid(value);
  }
  static constexpr RetType RetType_MIN =
    ReqSatelliteFind_RetType_RetType_MIN;
  static constexpr RetType RetType_MAX =
    ReqSatelliteFind_RetType_RetType_MAX;
  static constexpr int RetType_ARRAYSIZE =
    ReqSatelliteFind_RetType_RetType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  RetType_descriptor() {
    return ReqSatelliteFind_RetType_descriptor();
  }
  template<typename T>
  static inline const std::string& RetType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, RetType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function RetType_Name.");
    return ReqSatelliteFind_RetType_Name(enum_t_value);
  }
  static inline bool RetType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      RetType* value) {
    return ReqSatelliteFind_RetType_Parse(name, value);
  }

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

  enum : int {
    kElementFieldNumber = 3,
    kNoradFieldNumber = 2,
    kIdFieldNumber = 1,
    kRetTypeFieldNumber = 4,
  };
  // repeated string element = 3;
  int element_size() const;
  private:
  int _internal_element_size() const;
  public:
  void clear_element();
  const std::string& element(int index) const;
  std::string* mutable_element(int index);
  void set_element(int index, const std::string& value);
  void set_element(int index, std::string&& value);
  void set_element(int index, const char* value);
  void set_element(int index, const char* value, size_t size);
  std::string* add_element();
  void add_element(const std::string& value);
  void add_element(std::string&& value);
  void add_element(const char* value);
  void add_element(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& element() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_element();
  private:
  const std::string& _internal_element(int index) const;
  std::string* _internal_add_element();
  public:

  // string norad = 2;
  void clear_norad();
  const std::string& norad() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_norad(ArgT0&& arg0, ArgT... args);
  std::string* mutable_norad();
  PROTOBUF_NODISCARD std::string* release_norad();
  void set_allocated_norad(std::string* norad);
  private:
  const std::string& _internal_norad() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_norad(const std::string& value);
  std::string* _internal_mutable_norad();
  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:

  // .ReqSatelliteFind.RetType retType = 4;
  void clear_rettype();
  ::ReqSatelliteFind_RetType rettype() const;
  void set_rettype(::ReqSatelliteFind_RetType value);
  private:
  ::ReqSatelliteFind_RetType _internal_rettype() const;
  void _internal_set_rettype(::ReqSatelliteFind_RetType value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> element_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr norad_;
  int32_t id_;
  int rettype_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2dsatellite_2eproto;
};
// ===================================================================


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

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

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

// string name = 2;
inline void RetSatelliteElement::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& RetSatelliteElement::name() const {
  // @@protoc_insertion_point(field_get:RetSatelliteElement.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteElement::set_name(ArgT0&& arg0, ArgT... args) {
 
 name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteElement.name)
}
inline std::string* RetSatelliteElement::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:RetSatelliteElement.name)
  return _s;
}
inline const std::string& RetSatelliteElement::_internal_name() const {
  return name_.Get();
}
inline void RetSatelliteElement::_internal_set_name(const std::string& value) {
  
  name_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteElement::_internal_mutable_name() {
  
  return name_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteElement::release_name() {
  // @@protoc_insertion_point(field_release:RetSatelliteElement.name)
  return name_.Release();
}
inline void RetSatelliteElement::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault()) {
    name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteElement.name)
}

// string norad = 3;
inline void RetSatelliteElement::clear_norad() {
  norad_.ClearToEmpty();
}
inline const std::string& RetSatelliteElement::norad() const {
  // @@protoc_insertion_point(field_get:RetSatelliteElement.norad)
  return _internal_norad();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteElement::set_norad(ArgT0&& arg0, ArgT... args) {
 
 norad_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteElement.norad)
}
inline std::string* RetSatelliteElement::mutable_norad() {
  std::string* _s = _internal_mutable_norad();
  // @@protoc_insertion_point(field_mutable:RetSatelliteElement.norad)
  return _s;
}
inline const std::string& RetSatelliteElement::_internal_norad() const {
  return norad_.Get();
}
inline void RetSatelliteElement::_internal_set_norad(const std::string& value) {
  
  norad_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteElement::_internal_mutable_norad() {
  
  return norad_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteElement::release_norad() {
  // @@protoc_insertion_point(field_release:RetSatelliteElement.norad)
  return norad_.Release();
}
inline void RetSatelliteElement::set_allocated_norad(std::string* norad) {
  if (norad != nullptr) {
    
  } else {
    
  }
  norad_.SetAllocated(norad, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (norad_.IsDefault()) {
    norad_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteElement.norad)
}

// string code = 4;
inline void RetSatelliteElement::clear_code() {
  code_.ClearToEmpty();
}
inline const std::string& RetSatelliteElement::code() const {
  // @@protoc_insertion_point(field_get:RetSatelliteElement.code)
  return _internal_code();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteElement::set_code(ArgT0&& arg0, ArgT... args) {
 
 code_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteElement.code)
}
inline std::string* RetSatelliteElement::mutable_code() {
  std::string* _s = _internal_mutable_code();
  // @@protoc_insertion_point(field_mutable:RetSatelliteElement.code)
  return _s;
}
inline const std::string& RetSatelliteElement::_internal_code() const {
  return code_.Get();
}
inline void RetSatelliteElement::_internal_set_code(const std::string& value) {
  
  code_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteElement::_internal_mutable_code() {
  
  return code_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteElement::release_code() {
  // @@protoc_insertion_point(field_release:RetSatelliteElement.code)
  return code_.Release();
}
inline void RetSatelliteElement::set_allocated_code(std::string* code) {
  if (code != nullptr) {
    
  } else {
    
  }
  code_.SetAllocated(code, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (code_.IsDefault()) {
    code_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteElement.code)
}

// string codeCenter = 5;
inline void RetSatelliteElement::clear_codecenter() {
  codecenter_.ClearToEmpty();
}
inline const std::string& RetSatelliteElement::codecenter() const {
  // @@protoc_insertion_point(field_get:RetSatelliteElement.codeCenter)
  return _internal_codecenter();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteElement::set_codecenter(ArgT0&& arg0, ArgT... args) {
 
 codecenter_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteElement.codeCenter)
}
inline std::string* RetSatelliteElement::mutable_codecenter() {
  std::string* _s = _internal_mutable_codecenter();
  // @@protoc_insertion_point(field_mutable:RetSatelliteElement.codeCenter)
  return _s;
}
inline const std::string& RetSatelliteElement::_internal_codecenter() const {
  return codecenter_.Get();
}
inline void RetSatelliteElement::_internal_set_codecenter(const std::string& value) {
  
  codecenter_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteElement::_internal_mutable_codecenter() {
  
  return codecenter_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteElement::release_codecenter() {
  // @@protoc_insertion_point(field_release:RetSatelliteElement.codeCenter)
  return codecenter_.Release();
}
inline void RetSatelliteElement::set_allocated_codecenter(std::string* codecenter) {
  if (codecenter != nullptr) {
    
  } else {
    
  }
  codecenter_.SetAllocated(codecenter, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (codecenter_.IsDefault()) {
    codecenter_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteElement.codeCenter)
}

// string dt = 6;
inline void RetSatelliteElement::clear_dt() {
  dt_.ClearToEmpty();
}
inline const std::string& RetSatelliteElement::dt() const {
  // @@protoc_insertion_point(field_get:RetSatelliteElement.dt)
  return _internal_dt();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteElement::set_dt(ArgT0&& arg0, ArgT... args) {
 
 dt_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteElement.dt)
}
inline std::string* RetSatelliteElement::mutable_dt() {
  std::string* _s = _internal_mutable_dt();
  // @@protoc_insertion_point(field_mutable:RetSatelliteElement.dt)
  return _s;
}
inline const std::string& RetSatelliteElement::_internal_dt() const {
  return dt_.Get();
}
inline void RetSatelliteElement::_internal_set_dt(const std::string& value) {
  
  dt_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteElement::_internal_mutable_dt() {
  
  return dt_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteElement::release_dt() {
  // @@protoc_insertion_point(field_release:RetSatelliteElement.dt)
  return dt_.Release();
}
inline void RetSatelliteElement::set_allocated_dt(std::string* dt) {
  if (dt != nullptr) {
    
  } else {
    
  }
  dt_.SetAllocated(dt, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (dt_.IsDefault()) {
    dt_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteElement.dt)
}

// string updateDt = 7;
inline void RetSatelliteElement::clear_updatedt() {
  updatedt_.ClearToEmpty();
}
inline const std::string& RetSatelliteElement::updatedt() const {
  // @@protoc_insertion_point(field_get:RetSatelliteElement.updateDt)
  return _internal_updatedt();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteElement::set_updatedt(ArgT0&& arg0, ArgT... args) {
 
 updatedt_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteElement.updateDt)
}
inline std::string* RetSatelliteElement::mutable_updatedt() {
  std::string* _s = _internal_mutable_updatedt();
  // @@protoc_insertion_point(field_mutable:RetSatelliteElement.updateDt)
  return _s;
}
inline const std::string& RetSatelliteElement::_internal_updatedt() const {
  return updatedt_.Get();
}
inline void RetSatelliteElement::_internal_set_updatedt(const std::string& value) {
  
  updatedt_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteElement::_internal_mutable_updatedt() {
  
  return updatedt_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteElement::release_updatedt() {
  // @@protoc_insertion_point(field_release:RetSatelliteElement.updateDt)
  return updatedt_.Release();
}
inline void RetSatelliteElement::set_allocated_updatedt(std::string* updatedt) {
  if (updatedt != nullptr) {
    
  } else {
    
  }
  updatedt_.SetAllocated(updatedt, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (updatedt_.IsDefault()) {
    updatedt_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteElement.updateDt)
}

// double e = 8;
inline void RetSatelliteElement::clear_e() {
  e_ = 0;
}
inline double RetSatelliteElement::_internal_e() const {
  return e_;
}
inline double RetSatelliteElement::e() const {
  // @@protoc_insertion_point(field_get:RetSatelliteElement.e)
  return _internal_e();
}
inline void RetSatelliteElement::_internal_set_e(double value) {
  
  e_ = value;
}
inline void RetSatelliteElement::set_e(double value) {
  _internal_set_e(value);
  // @@protoc_insertion_point(field_set:RetSatelliteElement.e)
}

// double a = 9;
inline void RetSatelliteElement::clear_a() {
  a_ = 0;
}
inline double RetSatelliteElement::_internal_a() const {
  return a_;
}
inline double RetSatelliteElement::a() const {
  // @@protoc_insertion_point(field_get:RetSatelliteElement.a)
  return _internal_a();
}
inline void RetSatelliteElement::_internal_set_a(double value) {
  
  a_ = value;
}
inline void RetSatelliteElement::set_a(double value) {
  _internal_set_a(value);
  // @@protoc_insertion_point(field_set:RetSatelliteElement.a)
}

// double i = 10;
inline void RetSatelliteElement::clear_i() {
  i_ = 0;
}
inline double RetSatelliteElement::_internal_i() const {
  return i_;
}
inline double RetSatelliteElement::i() const {
  // @@protoc_insertion_point(field_get:RetSatelliteElement.i)
  return _internal_i();
}
inline void RetSatelliteElement::_internal_set_i(double value) {
  
  i_ = value;
}
inline void RetSatelliteElement::set_i(double value) {
  _internal_set_i(value);
  // @@protoc_insertion_point(field_set:RetSatelliteElement.i)
}

// double o = 11;
inline void RetSatelliteElement::clear_o() {
  o_ = 0;
}
inline double RetSatelliteElement::_internal_o() const {
  return o_;
}
inline double RetSatelliteElement::o() const {
  // @@protoc_insertion_point(field_get:RetSatelliteElement.o)
  return _internal_o();
}
inline void RetSatelliteElement::_internal_set_o(double value) {
  
  o_ = value;
}
inline void RetSatelliteElement::set_o(double value) {
  _internal_set_o(value);
  // @@protoc_insertion_point(field_set:RetSatelliteElement.o)
}

// double w = 12;
inline void RetSatelliteElement::clear_w() {
  w_ = 0;
}
inline double RetSatelliteElement::_internal_w() const {
  return w_;
}
inline double RetSatelliteElement::w() const {
  // @@protoc_insertion_point(field_get:RetSatelliteElement.w)
  return _internal_w();
}
inline void RetSatelliteElement::_internal_set_w(double value) {
  
  w_ = value;
}
inline void RetSatelliteElement::set_w(double value) {
  _internal_set_w(value);
  // @@protoc_insertion_point(field_set:RetSatelliteElement.w)
}

// double m = 13;
inline void RetSatelliteElement::clear_m() {
  m_ = 0;
}
inline double RetSatelliteElement::_internal_m() const {
  return m_;
}
inline double RetSatelliteElement::m() const {
  // @@protoc_insertion_point(field_get:RetSatelliteElement.m)
  return _internal_m();
}
inline void RetSatelliteElement::_internal_set_m(double value) {
  
  m_ = value;
}
inline void RetSatelliteElement::set_m(double value) {
  _internal_set_m(value);
  // @@protoc_insertion_point(field_set:RetSatelliteElement.m)
}

// double period = 14;
inline void RetSatelliteElement::clear_period() {
  period_ = 0;
}
inline double RetSatelliteElement::_internal_period() const {
  return period_;
}
inline double RetSatelliteElement::period() const {
  // @@protoc_insertion_point(field_get:RetSatelliteElement.period)
  return _internal_period();
}
inline void RetSatelliteElement::_internal_set_period(double value) {
  
  period_ = value;
}
inline void RetSatelliteElement::set_period(double value) {
  _internal_set_period(value);
  // @@protoc_insertion_point(field_set:RetSatelliteElement.period)
}

// string tle = 15;
inline void RetSatelliteElement::clear_tle() {
  tle_.ClearToEmpty();
}
inline const std::string& RetSatelliteElement::tle() const {
  // @@protoc_insertion_point(field_get:RetSatelliteElement.tle)
  return _internal_tle();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteElement::set_tle(ArgT0&& arg0, ArgT... args) {
 
 tle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteElement.tle)
}
inline std::string* RetSatelliteElement::mutable_tle() {
  std::string* _s = _internal_mutable_tle();
  // @@protoc_insertion_point(field_mutable:RetSatelliteElement.tle)
  return _s;
}
inline const std::string& RetSatelliteElement::_internal_tle() const {
  return tle_.Get();
}
inline void RetSatelliteElement::_internal_set_tle(const std::string& value) {
  
  tle_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteElement::_internal_mutable_tle() {
  
  return tle_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteElement::release_tle() {
  // @@protoc_insertion_point(field_release:RetSatelliteElement.tle)
  return tle_.Release();
}
inline void RetSatelliteElement::set_allocated_tle(std::string* tle) {
  if (tle != nullptr) {
    
  } else {
    
  }
  tle_.SetAllocated(tle, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (tle_.IsDefault()) {
    tle_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteElement.tle)
}

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

// ReqSatelliteDel

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

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

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

// ReqSatelliteElementUpdate

// string tle = 1;
inline void ReqSatelliteElementUpdate::clear_tle() {
  tle_.ClearToEmpty();
}
inline const std::string& ReqSatelliteElementUpdate::tle() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteElementUpdate.tle)
  return _internal_tle();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqSatelliteElementUpdate::set_tle(ArgT0&& arg0, ArgT... args) {
 
 tle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqSatelliteElementUpdate.tle)
}
inline std::string* ReqSatelliteElementUpdate::mutable_tle() {
  std::string* _s = _internal_mutable_tle();
  // @@protoc_insertion_point(field_mutable:ReqSatelliteElementUpdate.tle)
  return _s;
}
inline const std::string& ReqSatelliteElementUpdate::_internal_tle() const {
  return tle_.Get();
}
inline void ReqSatelliteElementUpdate::_internal_set_tle(const std::string& value) {
  
  tle_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqSatelliteElementUpdate::_internal_mutable_tle() {
  
  return tle_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqSatelliteElementUpdate::release_tle() {
  // @@protoc_insertion_point(field_release:ReqSatelliteElementUpdate.tle)
  return tle_.Release();
}
inline void ReqSatelliteElementUpdate::set_allocated_tle(std::string* tle) {
  if (tle != nullptr) {
    
  } else {
    
  }
  tle_.SetAllocated(tle, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (tle_.IsDefault()) {
    tle_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqSatelliteElementUpdate.tle)
}

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

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

// ReqSatelliteInfoUpdate

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

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

// string cnName = 3;
inline void ReqSatelliteInfoUpdate::clear_cnname() {
  cnname_.ClearToEmpty();
}
inline const std::string& ReqSatelliteInfoUpdate::cnname() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteInfoUpdate.cnName)
  return _internal_cnname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqSatelliteInfoUpdate::set_cnname(ArgT0&& arg0, ArgT... args) {
 
 cnname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqSatelliteInfoUpdate.cnName)
}
inline std::string* ReqSatelliteInfoUpdate::mutable_cnname() {
  std::string* _s = _internal_mutable_cnname();
  // @@protoc_insertion_point(field_mutable:ReqSatelliteInfoUpdate.cnName)
  return _s;
}
inline const std::string& ReqSatelliteInfoUpdate::_internal_cnname() const {
  return cnname_.Get();
}
inline void ReqSatelliteInfoUpdate::_internal_set_cnname(const std::string& value) {
  
  cnname_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::_internal_mutable_cnname() {
  
  return cnname_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::release_cnname() {
  // @@protoc_insertion_point(field_release:ReqSatelliteInfoUpdate.cnName)
  return cnname_.Release();
}
inline void ReqSatelliteInfoUpdate::set_allocated_cnname(std::string* cnname) {
  if (cnname != nullptr) {
    
  } else {
    
  }
  cnname_.SetAllocated(cnname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (cnname_.IsDefault()) {
    cnname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqSatelliteInfoUpdate.cnName)
}

// string enName = 4;
inline void ReqSatelliteInfoUpdate::clear_enname() {
  enname_.ClearToEmpty();
}
inline const std::string& ReqSatelliteInfoUpdate::enname() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteInfoUpdate.enName)
  return _internal_enname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqSatelliteInfoUpdate::set_enname(ArgT0&& arg0, ArgT... args) {
 
 enname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqSatelliteInfoUpdate.enName)
}
inline std::string* ReqSatelliteInfoUpdate::mutable_enname() {
  std::string* _s = _internal_mutable_enname();
  // @@protoc_insertion_point(field_mutable:ReqSatelliteInfoUpdate.enName)
  return _s;
}
inline const std::string& ReqSatelliteInfoUpdate::_internal_enname() const {
  return enname_.Get();
}
inline void ReqSatelliteInfoUpdate::_internal_set_enname(const std::string& value) {
  
  enname_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::_internal_mutable_enname() {
  
  return enname_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::release_enname() {
  // @@protoc_insertion_point(field_release:ReqSatelliteInfoUpdate.enName)
  return enname_.Release();
}
inline void ReqSatelliteInfoUpdate::set_allocated_enname(std::string* enname) {
  if (enname != nullptr) {
    
  } else {
    
  }
  enname_.SetAllocated(enname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (enname_.IsDefault()) {
    enname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqSatelliteInfoUpdate.enName)
}

// string country = 5;
inline void ReqSatelliteInfoUpdate::clear_country() {
  country_.ClearToEmpty();
}
inline const std::string& ReqSatelliteInfoUpdate::country() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteInfoUpdate.country)
  return _internal_country();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqSatelliteInfoUpdate::set_country(ArgT0&& arg0, ArgT... args) {
 
 country_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqSatelliteInfoUpdate.country)
}
inline std::string* ReqSatelliteInfoUpdate::mutable_country() {
  std::string* _s = _internal_mutable_country();
  // @@protoc_insertion_point(field_mutable:ReqSatelliteInfoUpdate.country)
  return _s;
}
inline const std::string& ReqSatelliteInfoUpdate::_internal_country() const {
  return country_.Get();
}
inline void ReqSatelliteInfoUpdate::_internal_set_country(const std::string& value) {
  
  country_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::_internal_mutable_country() {
  
  return country_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::release_country() {
  // @@protoc_insertion_point(field_release:ReqSatelliteInfoUpdate.country)
  return country_.Release();
}
inline void ReqSatelliteInfoUpdate::set_allocated_country(std::string* country) {
  if (country != nullptr) {
    
  } else {
    
  }
  country_.SetAllocated(country, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (country_.IsDefault()) {
    country_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqSatelliteInfoUpdate.country)
}

// string type = 6;
inline void ReqSatelliteInfoUpdate::clear_type() {
  type_.ClearToEmpty();
}
inline const std::string& ReqSatelliteInfoUpdate::type() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteInfoUpdate.type)
  return _internal_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqSatelliteInfoUpdate::set_type(ArgT0&& arg0, ArgT... args) {
 
 type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqSatelliteInfoUpdate.type)
}
inline std::string* ReqSatelliteInfoUpdate::mutable_type() {
  std::string* _s = _internal_mutable_type();
  // @@protoc_insertion_point(field_mutable:ReqSatelliteInfoUpdate.type)
  return _s;
}
inline const std::string& ReqSatelliteInfoUpdate::_internal_type() const {
  return type_.Get();
}
inline void ReqSatelliteInfoUpdate::_internal_set_type(const std::string& value) {
  
  type_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::_internal_mutable_type() {
  
  return type_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::release_type() {
  // @@protoc_insertion_point(field_release:ReqSatelliteInfoUpdate.type)
  return type_.Release();
}
inline void ReqSatelliteInfoUpdate::set_allocated_type(std::string* type) {
  if (type != nullptr) {
    
  } else {
    
  }
  type_.SetAllocated(type, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (type_.IsDefault()) {
    type_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqSatelliteInfoUpdate.type)
}

// string purpose = 7;
inline void ReqSatelliteInfoUpdate::clear_purpose() {
  purpose_.ClearToEmpty();
}
inline const std::string& ReqSatelliteInfoUpdate::purpose() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteInfoUpdate.purpose)
  return _internal_purpose();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqSatelliteInfoUpdate::set_purpose(ArgT0&& arg0, ArgT... args) {
 
 purpose_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqSatelliteInfoUpdate.purpose)
}
inline std::string* ReqSatelliteInfoUpdate::mutable_purpose() {
  std::string* _s = _internal_mutable_purpose();
  // @@protoc_insertion_point(field_mutable:ReqSatelliteInfoUpdate.purpose)
  return _s;
}
inline const std::string& ReqSatelliteInfoUpdate::_internal_purpose() const {
  return purpose_.Get();
}
inline void ReqSatelliteInfoUpdate::_internal_set_purpose(const std::string& value) {
  
  purpose_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::_internal_mutable_purpose() {
  
  return purpose_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::release_purpose() {
  // @@protoc_insertion_point(field_release:ReqSatelliteInfoUpdate.purpose)
  return purpose_.Release();
}
inline void ReqSatelliteInfoUpdate::set_allocated_purpose(std::string* purpose) {
  if (purpose != nullptr) {
    
  } else {
    
  }
  purpose_.SetAllocated(purpose, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (purpose_.IsDefault()) {
    purpose_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqSatelliteInfoUpdate.purpose)
}

// string observeGrade = 8;
inline void ReqSatelliteInfoUpdate::clear_observegrade() {
  observegrade_.ClearToEmpty();
}
inline const std::string& ReqSatelliteInfoUpdate::observegrade() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteInfoUpdate.observeGrade)
  return _internal_observegrade();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqSatelliteInfoUpdate::set_observegrade(ArgT0&& arg0, ArgT... args) {
 
 observegrade_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqSatelliteInfoUpdate.observeGrade)
}
inline std::string* ReqSatelliteInfoUpdate::mutable_observegrade() {
  std::string* _s = _internal_mutable_observegrade();
  // @@protoc_insertion_point(field_mutable:ReqSatelliteInfoUpdate.observeGrade)
  return _s;
}
inline const std::string& ReqSatelliteInfoUpdate::_internal_observegrade() const {
  return observegrade_.Get();
}
inline void ReqSatelliteInfoUpdate::_internal_set_observegrade(const std::string& value) {
  
  observegrade_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::_internal_mutable_observegrade() {
  
  return observegrade_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::release_observegrade() {
  // @@protoc_insertion_point(field_release:ReqSatelliteInfoUpdate.observeGrade)
  return observegrade_.Release();
}
inline void ReqSatelliteInfoUpdate::set_allocated_observegrade(std::string* observegrade) {
  if (observegrade != nullptr) {
    
  } else {
    
  }
  observegrade_.SetAllocated(observegrade, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (observegrade_.IsDefault()) {
    observegrade_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqSatelliteInfoUpdate.observeGrade)
}

// string launchDt = 9;
inline void ReqSatelliteInfoUpdate::clear_launchdt() {
  launchdt_.ClearToEmpty();
}
inline const std::string& ReqSatelliteInfoUpdate::launchdt() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteInfoUpdate.launchDt)
  return _internal_launchdt();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqSatelliteInfoUpdate::set_launchdt(ArgT0&& arg0, ArgT... args) {
 
 launchdt_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqSatelliteInfoUpdate.launchDt)
}
inline std::string* ReqSatelliteInfoUpdate::mutable_launchdt() {
  std::string* _s = _internal_mutable_launchdt();
  // @@protoc_insertion_point(field_mutable:ReqSatelliteInfoUpdate.launchDt)
  return _s;
}
inline const std::string& ReqSatelliteInfoUpdate::_internal_launchdt() const {
  return launchdt_.Get();
}
inline void ReqSatelliteInfoUpdate::_internal_set_launchdt(const std::string& value) {
  
  launchdt_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::_internal_mutable_launchdt() {
  
  return launchdt_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::release_launchdt() {
  // @@protoc_insertion_point(field_release:ReqSatelliteInfoUpdate.launchDt)
  return launchdt_.Release();
}
inline void ReqSatelliteInfoUpdate::set_allocated_launchdt(std::string* launchdt) {
  if (launchdt != nullptr) {
    
  } else {
    
  }
  launchdt_.SetAllocated(launchdt, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (launchdt_.IsDefault()) {
    launchdt_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqSatelliteInfoUpdate.launchDt)
}

// string launchPlace = 10;
inline void ReqSatelliteInfoUpdate::clear_launchplace() {
  launchplace_.ClearToEmpty();
}
inline const std::string& ReqSatelliteInfoUpdate::launchplace() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteInfoUpdate.launchPlace)
  return _internal_launchplace();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqSatelliteInfoUpdate::set_launchplace(ArgT0&& arg0, ArgT... args) {
 
 launchplace_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqSatelliteInfoUpdate.launchPlace)
}
inline std::string* ReqSatelliteInfoUpdate::mutable_launchplace() {
  std::string* _s = _internal_mutable_launchplace();
  // @@protoc_insertion_point(field_mutable:ReqSatelliteInfoUpdate.launchPlace)
  return _s;
}
inline const std::string& ReqSatelliteInfoUpdate::_internal_launchplace() const {
  return launchplace_.Get();
}
inline void ReqSatelliteInfoUpdate::_internal_set_launchplace(const std::string& value) {
  
  launchplace_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::_internal_mutable_launchplace() {
  
  return launchplace_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::release_launchplace() {
  // @@protoc_insertion_point(field_release:ReqSatelliteInfoUpdate.launchPlace)
  return launchplace_.Release();
}
inline void ReqSatelliteInfoUpdate::set_allocated_launchplace(std::string* launchplace) {
  if (launchplace != nullptr) {
    
  } else {
    
  }
  launchplace_.SetAllocated(launchplace, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (launchplace_.IsDefault()) {
    launchplace_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqSatelliteInfoUpdate.launchPlace)
}

// string carrierRocket = 11;
inline void ReqSatelliteInfoUpdate::clear_carrierrocket() {
  carrierrocket_.ClearToEmpty();
}
inline const std::string& ReqSatelliteInfoUpdate::carrierrocket() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteInfoUpdate.carrierRocket)
  return _internal_carrierrocket();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqSatelliteInfoUpdate::set_carrierrocket(ArgT0&& arg0, ArgT... args) {
 
 carrierrocket_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqSatelliteInfoUpdate.carrierRocket)
}
inline std::string* ReqSatelliteInfoUpdate::mutable_carrierrocket() {
  std::string* _s = _internal_mutable_carrierrocket();
  // @@protoc_insertion_point(field_mutable:ReqSatelliteInfoUpdate.carrierRocket)
  return _s;
}
inline const std::string& ReqSatelliteInfoUpdate::_internal_carrierrocket() const {
  return carrierrocket_.Get();
}
inline void ReqSatelliteInfoUpdate::_internal_set_carrierrocket(const std::string& value) {
  
  carrierrocket_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::_internal_mutable_carrierrocket() {
  
  return carrierrocket_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::release_carrierrocket() {
  // @@protoc_insertion_point(field_release:ReqSatelliteInfoUpdate.carrierRocket)
  return carrierrocket_.Release();
}
inline void ReqSatelliteInfoUpdate::set_allocated_carrierrocket(std::string* carrierrocket) {
  if (carrierrocket != nullptr) {
    
  } else {
    
  }
  carrierrocket_.SetAllocated(carrierrocket, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (carrierrocket_.IsDefault()) {
    carrierrocket_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqSatelliteInfoUpdate.carrierRocket)
}

// string ageLimit = 12;
inline void ReqSatelliteInfoUpdate::clear_agelimit() {
  agelimit_.ClearToEmpty();
}
inline const std::string& ReqSatelliteInfoUpdate::agelimit() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteInfoUpdate.ageLimit)
  return _internal_agelimit();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqSatelliteInfoUpdate::set_agelimit(ArgT0&& arg0, ArgT... args) {
 
 agelimit_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqSatelliteInfoUpdate.ageLimit)
}
inline std::string* ReqSatelliteInfoUpdate::mutable_agelimit() {
  std::string* _s = _internal_mutable_agelimit();
  // @@protoc_insertion_point(field_mutable:ReqSatelliteInfoUpdate.ageLimit)
  return _s;
}
inline const std::string& ReqSatelliteInfoUpdate::_internal_agelimit() const {
  return agelimit_.Get();
}
inline void ReqSatelliteInfoUpdate::_internal_set_agelimit(const std::string& value) {
  
  agelimit_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::_internal_mutable_agelimit() {
  
  return agelimit_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::release_agelimit() {
  // @@protoc_insertion_point(field_release:ReqSatelliteInfoUpdate.ageLimit)
  return agelimit_.Release();
}
inline void ReqSatelliteInfoUpdate::set_allocated_agelimit(std::string* agelimit) {
  if (agelimit != nullptr) {
    
  } else {
    
  }
  agelimit_.SetAllocated(agelimit, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (agelimit_.IsDefault()) {
    agelimit_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqSatelliteInfoUpdate.ageLimit)
}

// string manager = 13;
inline void ReqSatelliteInfoUpdate::clear_manager() {
  manager_.ClearToEmpty();
}
inline const std::string& ReqSatelliteInfoUpdate::manager() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteInfoUpdate.manager)
  return _internal_manager();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqSatelliteInfoUpdate::set_manager(ArgT0&& arg0, ArgT... args) {
 
 manager_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqSatelliteInfoUpdate.manager)
}
inline std::string* ReqSatelliteInfoUpdate::mutable_manager() {
  std::string* _s = _internal_mutable_manager();
  // @@protoc_insertion_point(field_mutable:ReqSatelliteInfoUpdate.manager)
  return _s;
}
inline const std::string& ReqSatelliteInfoUpdate::_internal_manager() const {
  return manager_.Get();
}
inline void ReqSatelliteInfoUpdate::_internal_set_manager(const std::string& value) {
  
  manager_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::_internal_mutable_manager() {
  
  return manager_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::release_manager() {
  // @@protoc_insertion_point(field_release:ReqSatelliteInfoUpdate.manager)
  return manager_.Release();
}
inline void ReqSatelliteInfoUpdate::set_allocated_manager(std::string* manager) {
  if (manager != nullptr) {
    
  } else {
    
  }
  manager_.SetAllocated(manager, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (manager_.IsDefault()) {
    manager_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqSatelliteInfoUpdate.manager)
}

// string contractor = 14;
inline void ReqSatelliteInfoUpdate::clear_contractor() {
  contractor_.ClearToEmpty();
}
inline const std::string& ReqSatelliteInfoUpdate::contractor() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteInfoUpdate.contractor)
  return _internal_contractor();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqSatelliteInfoUpdate::set_contractor(ArgT0&& arg0, ArgT... args) {
 
 contractor_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqSatelliteInfoUpdate.contractor)
}
inline std::string* ReqSatelliteInfoUpdate::mutable_contractor() {
  std::string* _s = _internal_mutable_contractor();
  // @@protoc_insertion_point(field_mutable:ReqSatelliteInfoUpdate.contractor)
  return _s;
}
inline const std::string& ReqSatelliteInfoUpdate::_internal_contractor() const {
  return contractor_.Get();
}
inline void ReqSatelliteInfoUpdate::_internal_set_contractor(const std::string& value) {
  
  contractor_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::_internal_mutable_contractor() {
  
  return contractor_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::release_contractor() {
  // @@protoc_insertion_point(field_release:ReqSatelliteInfoUpdate.contractor)
  return contractor_.Release();
}
inline void ReqSatelliteInfoUpdate::set_allocated_contractor(std::string* contractor) {
  if (contractor != nullptr) {
    
  } else {
    
  }
  contractor_.SetAllocated(contractor, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (contractor_.IsDefault()) {
    contractor_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqSatelliteInfoUpdate.contractor)
}

// string platform = 15;
inline void ReqSatelliteInfoUpdate::clear_platform() {
  platform_.ClearToEmpty();
}
inline const std::string& ReqSatelliteInfoUpdate::platform() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteInfoUpdate.platform)
  return _internal_platform();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqSatelliteInfoUpdate::set_platform(ArgT0&& arg0, ArgT... args) {
 
 platform_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqSatelliteInfoUpdate.platform)
}
inline std::string* ReqSatelliteInfoUpdate::mutable_platform() {
  std::string* _s = _internal_mutable_platform();
  // @@protoc_insertion_point(field_mutable:ReqSatelliteInfoUpdate.platform)
  return _s;
}
inline const std::string& ReqSatelliteInfoUpdate::_internal_platform() const {
  return platform_.Get();
}
inline void ReqSatelliteInfoUpdate::_internal_set_platform(const std::string& value) {
  
  platform_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::_internal_mutable_platform() {
  
  return platform_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::release_platform() {
  // @@protoc_insertion_point(field_release:ReqSatelliteInfoUpdate.platform)
  return platform_.Release();
}
inline void ReqSatelliteInfoUpdate::set_allocated_platform(std::string* platform) {
  if (platform != nullptr) {
    
  } else {
    
  }
  platform_.SetAllocated(platform, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (platform_.IsDefault()) {
    platform_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqSatelliteInfoUpdate.platform)
}

// string payload = 16;
inline void ReqSatelliteInfoUpdate::clear_payload() {
  payload_.ClearToEmpty();
}
inline const std::string& ReqSatelliteInfoUpdate::payload() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteInfoUpdate.payload)
  return _internal_payload();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqSatelliteInfoUpdate::set_payload(ArgT0&& arg0, ArgT... args) {
 
 payload_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqSatelliteInfoUpdate.payload)
}
inline std::string* ReqSatelliteInfoUpdate::mutable_payload() {
  std::string* _s = _internal_mutable_payload();
  // @@protoc_insertion_point(field_mutable:ReqSatelliteInfoUpdate.payload)
  return _s;
}
inline const std::string& ReqSatelliteInfoUpdate::_internal_payload() const {
  return payload_.Get();
}
inline void ReqSatelliteInfoUpdate::_internal_set_payload(const std::string& value) {
  
  payload_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::_internal_mutable_payload() {
  
  return payload_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::release_payload() {
  // @@protoc_insertion_point(field_release:ReqSatelliteInfoUpdate.payload)
  return payload_.Release();
}
inline void ReqSatelliteInfoUpdate::set_allocated_payload(std::string* payload) {
  if (payload != nullptr) {
    
  } else {
    
  }
  payload_.SetAllocated(payload, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (payload_.IsDefault()) {
    payload_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqSatelliteInfoUpdate.payload)
}

// string booster = 17;
inline void ReqSatelliteInfoUpdate::clear_booster() {
  booster_.ClearToEmpty();
}
inline const std::string& ReqSatelliteInfoUpdate::booster() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteInfoUpdate.booster)
  return _internal_booster();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqSatelliteInfoUpdate::set_booster(ArgT0&& arg0, ArgT... args) {
 
 booster_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqSatelliteInfoUpdate.booster)
}
inline std::string* ReqSatelliteInfoUpdate::mutable_booster() {
  std::string* _s = _internal_mutable_booster();
  // @@protoc_insertion_point(field_mutable:ReqSatelliteInfoUpdate.booster)
  return _s;
}
inline const std::string& ReqSatelliteInfoUpdate::_internal_booster() const {
  return booster_.Get();
}
inline void ReqSatelliteInfoUpdate::_internal_set_booster(const std::string& value) {
  
  booster_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::_internal_mutable_booster() {
  
  return booster_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::release_booster() {
  // @@protoc_insertion_point(field_release:ReqSatelliteInfoUpdate.booster)
  return booster_.Release();
}
inline void ReqSatelliteInfoUpdate::set_allocated_booster(std::string* booster) {
  if (booster != nullptr) {
    
  } else {
    
  }
  booster_.SetAllocated(booster, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (booster_.IsDefault()) {
    booster_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqSatelliteInfoUpdate.booster)
}

// string power = 18;
inline void ReqSatelliteInfoUpdate::clear_power() {
  power_.ClearToEmpty();
}
inline const std::string& ReqSatelliteInfoUpdate::power() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteInfoUpdate.power)
  return _internal_power();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqSatelliteInfoUpdate::set_power(ArgT0&& arg0, ArgT... args) {
 
 power_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqSatelliteInfoUpdate.power)
}
inline std::string* ReqSatelliteInfoUpdate::mutable_power() {
  std::string* _s = _internal_mutable_power();
  // @@protoc_insertion_point(field_mutable:ReqSatelliteInfoUpdate.power)
  return _s;
}
inline const std::string& ReqSatelliteInfoUpdate::_internal_power() const {
  return power_.Get();
}
inline void ReqSatelliteInfoUpdate::_internal_set_power(const std::string& value) {
  
  power_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::_internal_mutable_power() {
  
  return power_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::release_power() {
  // @@protoc_insertion_point(field_release:ReqSatelliteInfoUpdate.power)
  return power_.Release();
}
inline void ReqSatelliteInfoUpdate::set_allocated_power(std::string* power) {
  if (power != nullptr) {
    
  } else {
    
  }
  power_.SetAllocated(power, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (power_.IsDefault()) {
    power_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqSatelliteInfoUpdate.power)
}

// string mass = 19;
inline void ReqSatelliteInfoUpdate::clear_mass() {
  mass_.ClearToEmpty();
}
inline const std::string& ReqSatelliteInfoUpdate::mass() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteInfoUpdate.mass)
  return _internal_mass();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqSatelliteInfoUpdate::set_mass(ArgT0&& arg0, ArgT... args) {
 
 mass_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqSatelliteInfoUpdate.mass)
}
inline std::string* ReqSatelliteInfoUpdate::mutable_mass() {
  std::string* _s = _internal_mutable_mass();
  // @@protoc_insertion_point(field_mutable:ReqSatelliteInfoUpdate.mass)
  return _s;
}
inline const std::string& ReqSatelliteInfoUpdate::_internal_mass() const {
  return mass_.Get();
}
inline void ReqSatelliteInfoUpdate::_internal_set_mass(const std::string& value) {
  
  mass_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::_internal_mutable_mass() {
  
  return mass_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::release_mass() {
  // @@protoc_insertion_point(field_release:ReqSatelliteInfoUpdate.mass)
  return mass_.Release();
}
inline void ReqSatelliteInfoUpdate::set_allocated_mass(std::string* mass) {
  if (mass != nullptr) {
    
  } else {
    
  }
  mass_.SetAllocated(mass, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (mass_.IsDefault()) {
    mass_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqSatelliteInfoUpdate.mass)
}

// string orbitType = 20;
inline void ReqSatelliteInfoUpdate::clear_orbittype() {
  orbittype_.ClearToEmpty();
}
inline const std::string& ReqSatelliteInfoUpdate::orbittype() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteInfoUpdate.orbitType)
  return _internal_orbittype();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqSatelliteInfoUpdate::set_orbittype(ArgT0&& arg0, ArgT... args) {
 
 orbittype_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqSatelliteInfoUpdate.orbitType)
}
inline std::string* ReqSatelliteInfoUpdate::mutable_orbittype() {
  std::string* _s = _internal_mutable_orbittype();
  // @@protoc_insertion_point(field_mutable:ReqSatelliteInfoUpdate.orbitType)
  return _s;
}
inline const std::string& ReqSatelliteInfoUpdate::_internal_orbittype() const {
  return orbittype_.Get();
}
inline void ReqSatelliteInfoUpdate::_internal_set_orbittype(const std::string& value) {
  
  orbittype_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::_internal_mutable_orbittype() {
  
  return orbittype_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::release_orbittype() {
  // @@protoc_insertion_point(field_release:ReqSatelliteInfoUpdate.orbitType)
  return orbittype_.Release();
}
inline void ReqSatelliteInfoUpdate::set_allocated_orbittype(std::string* orbittype) {
  if (orbittype != nullptr) {
    
  } else {
    
  }
  orbittype_.SetAllocated(orbittype, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (orbittype_.IsDefault()) {
    orbittype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqSatelliteInfoUpdate.orbitType)
}

// string remark = 21;
inline void ReqSatelliteInfoUpdate::clear_remark() {
  remark_.ClearToEmpty();
}
inline const std::string& ReqSatelliteInfoUpdate::remark() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteInfoUpdate.remark)
  return _internal_remark();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqSatelliteInfoUpdate::set_remark(ArgT0&& arg0, ArgT... args) {
 
 remark_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqSatelliteInfoUpdate.remark)
}
inline std::string* ReqSatelliteInfoUpdate::mutable_remark() {
  std::string* _s = _internal_mutable_remark();
  // @@protoc_insertion_point(field_mutable:ReqSatelliteInfoUpdate.remark)
  return _s;
}
inline const std::string& ReqSatelliteInfoUpdate::_internal_remark() const {
  return remark_.Get();
}
inline void ReqSatelliteInfoUpdate::_internal_set_remark(const std::string& value) {
  
  remark_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::_internal_mutable_remark() {
  
  return remark_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqSatelliteInfoUpdate::release_remark() {
  // @@protoc_insertion_point(field_release:ReqSatelliteInfoUpdate.remark)
  return remark_.Release();
}
inline void ReqSatelliteInfoUpdate::set_allocated_remark(std::string* remark) {
  if (remark != nullptr) {
    
  } else {
    
  }
  remark_.SetAllocated(remark, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (remark_.IsDefault()) {
    remark_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqSatelliteInfoUpdate.remark)
}

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

// RetSatelliteInfoElement

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

// string cnName = 3;
inline void RetSatelliteInfoElement::clear_cnname() {
  cnname_.ClearToEmpty();
}
inline const std::string& RetSatelliteInfoElement::cnname() const {
  // @@protoc_insertion_point(field_get:RetSatelliteInfoElement.cnName)
  return _internal_cnname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteInfoElement::set_cnname(ArgT0&& arg0, ArgT... args) {
 
 cnname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteInfoElement.cnName)
}
inline std::string* RetSatelliteInfoElement::mutable_cnname() {
  std::string* _s = _internal_mutable_cnname();
  // @@protoc_insertion_point(field_mutable:RetSatelliteInfoElement.cnName)
  return _s;
}
inline const std::string& RetSatelliteInfoElement::_internal_cnname() const {
  return cnname_.Get();
}
inline void RetSatelliteInfoElement::_internal_set_cnname(const std::string& value) {
  
  cnname_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::_internal_mutable_cnname() {
  
  return cnname_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::release_cnname() {
  // @@protoc_insertion_point(field_release:RetSatelliteInfoElement.cnName)
  return cnname_.Release();
}
inline void RetSatelliteInfoElement::set_allocated_cnname(std::string* cnname) {
  if (cnname != nullptr) {
    
  } else {
    
  }
  cnname_.SetAllocated(cnname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (cnname_.IsDefault()) {
    cnname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteInfoElement.cnName)
}

// string enName = 4;
inline void RetSatelliteInfoElement::clear_enname() {
  enname_.ClearToEmpty();
}
inline const std::string& RetSatelliteInfoElement::enname() const {
  // @@protoc_insertion_point(field_get:RetSatelliteInfoElement.enName)
  return _internal_enname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteInfoElement::set_enname(ArgT0&& arg0, ArgT... args) {
 
 enname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteInfoElement.enName)
}
inline std::string* RetSatelliteInfoElement::mutable_enname() {
  std::string* _s = _internal_mutable_enname();
  // @@protoc_insertion_point(field_mutable:RetSatelliteInfoElement.enName)
  return _s;
}
inline const std::string& RetSatelliteInfoElement::_internal_enname() const {
  return enname_.Get();
}
inline void RetSatelliteInfoElement::_internal_set_enname(const std::string& value) {
  
  enname_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::_internal_mutable_enname() {
  
  return enname_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::release_enname() {
  // @@protoc_insertion_point(field_release:RetSatelliteInfoElement.enName)
  return enname_.Release();
}
inline void RetSatelliteInfoElement::set_allocated_enname(std::string* enname) {
  if (enname != nullptr) {
    
  } else {
    
  }
  enname_.SetAllocated(enname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (enname_.IsDefault()) {
    enname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteInfoElement.enName)
}

// string country = 5;
inline void RetSatelliteInfoElement::clear_country() {
  country_.ClearToEmpty();
}
inline const std::string& RetSatelliteInfoElement::country() const {
  // @@protoc_insertion_point(field_get:RetSatelliteInfoElement.country)
  return _internal_country();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteInfoElement::set_country(ArgT0&& arg0, ArgT... args) {
 
 country_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteInfoElement.country)
}
inline std::string* RetSatelliteInfoElement::mutable_country() {
  std::string* _s = _internal_mutable_country();
  // @@protoc_insertion_point(field_mutable:RetSatelliteInfoElement.country)
  return _s;
}
inline const std::string& RetSatelliteInfoElement::_internal_country() const {
  return country_.Get();
}
inline void RetSatelliteInfoElement::_internal_set_country(const std::string& value) {
  
  country_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::_internal_mutable_country() {
  
  return country_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::release_country() {
  // @@protoc_insertion_point(field_release:RetSatelliteInfoElement.country)
  return country_.Release();
}
inline void RetSatelliteInfoElement::set_allocated_country(std::string* country) {
  if (country != nullptr) {
    
  } else {
    
  }
  country_.SetAllocated(country, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (country_.IsDefault()) {
    country_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteInfoElement.country)
}

// string type = 6;
inline void RetSatelliteInfoElement::clear_type() {
  type_.ClearToEmpty();
}
inline const std::string& RetSatelliteInfoElement::type() const {
  // @@protoc_insertion_point(field_get:RetSatelliteInfoElement.type)
  return _internal_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteInfoElement::set_type(ArgT0&& arg0, ArgT... args) {
 
 type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteInfoElement.type)
}
inline std::string* RetSatelliteInfoElement::mutable_type() {
  std::string* _s = _internal_mutable_type();
  // @@protoc_insertion_point(field_mutable:RetSatelliteInfoElement.type)
  return _s;
}
inline const std::string& RetSatelliteInfoElement::_internal_type() const {
  return type_.Get();
}
inline void RetSatelliteInfoElement::_internal_set_type(const std::string& value) {
  
  type_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::_internal_mutable_type() {
  
  return type_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::release_type() {
  // @@protoc_insertion_point(field_release:RetSatelliteInfoElement.type)
  return type_.Release();
}
inline void RetSatelliteInfoElement::set_allocated_type(std::string* type) {
  if (type != nullptr) {
    
  } else {
    
  }
  type_.SetAllocated(type, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (type_.IsDefault()) {
    type_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteInfoElement.type)
}

// string purpose = 7;
inline void RetSatelliteInfoElement::clear_purpose() {
  purpose_.ClearToEmpty();
}
inline const std::string& RetSatelliteInfoElement::purpose() const {
  // @@protoc_insertion_point(field_get:RetSatelliteInfoElement.purpose)
  return _internal_purpose();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteInfoElement::set_purpose(ArgT0&& arg0, ArgT... args) {
 
 purpose_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteInfoElement.purpose)
}
inline std::string* RetSatelliteInfoElement::mutable_purpose() {
  std::string* _s = _internal_mutable_purpose();
  // @@protoc_insertion_point(field_mutable:RetSatelliteInfoElement.purpose)
  return _s;
}
inline const std::string& RetSatelliteInfoElement::_internal_purpose() const {
  return purpose_.Get();
}
inline void RetSatelliteInfoElement::_internal_set_purpose(const std::string& value) {
  
  purpose_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::_internal_mutable_purpose() {
  
  return purpose_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::release_purpose() {
  // @@protoc_insertion_point(field_release:RetSatelliteInfoElement.purpose)
  return purpose_.Release();
}
inline void RetSatelliteInfoElement::set_allocated_purpose(std::string* purpose) {
  if (purpose != nullptr) {
    
  } else {
    
  }
  purpose_.SetAllocated(purpose, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (purpose_.IsDefault()) {
    purpose_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteInfoElement.purpose)
}

// string observeGrade = 8;
inline void RetSatelliteInfoElement::clear_observegrade() {
  observegrade_.ClearToEmpty();
}
inline const std::string& RetSatelliteInfoElement::observegrade() const {
  // @@protoc_insertion_point(field_get:RetSatelliteInfoElement.observeGrade)
  return _internal_observegrade();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteInfoElement::set_observegrade(ArgT0&& arg0, ArgT... args) {
 
 observegrade_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteInfoElement.observeGrade)
}
inline std::string* RetSatelliteInfoElement::mutable_observegrade() {
  std::string* _s = _internal_mutable_observegrade();
  // @@protoc_insertion_point(field_mutable:RetSatelliteInfoElement.observeGrade)
  return _s;
}
inline const std::string& RetSatelliteInfoElement::_internal_observegrade() const {
  return observegrade_.Get();
}
inline void RetSatelliteInfoElement::_internal_set_observegrade(const std::string& value) {
  
  observegrade_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::_internal_mutable_observegrade() {
  
  return observegrade_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::release_observegrade() {
  // @@protoc_insertion_point(field_release:RetSatelliteInfoElement.observeGrade)
  return observegrade_.Release();
}
inline void RetSatelliteInfoElement::set_allocated_observegrade(std::string* observegrade) {
  if (observegrade != nullptr) {
    
  } else {
    
  }
  observegrade_.SetAllocated(observegrade, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (observegrade_.IsDefault()) {
    observegrade_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteInfoElement.observeGrade)
}

// string launchDt = 9;
inline void RetSatelliteInfoElement::clear_launchdt() {
  launchdt_.ClearToEmpty();
}
inline const std::string& RetSatelliteInfoElement::launchdt() const {
  // @@protoc_insertion_point(field_get:RetSatelliteInfoElement.launchDt)
  return _internal_launchdt();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteInfoElement::set_launchdt(ArgT0&& arg0, ArgT... args) {
 
 launchdt_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteInfoElement.launchDt)
}
inline std::string* RetSatelliteInfoElement::mutable_launchdt() {
  std::string* _s = _internal_mutable_launchdt();
  // @@protoc_insertion_point(field_mutable:RetSatelliteInfoElement.launchDt)
  return _s;
}
inline const std::string& RetSatelliteInfoElement::_internal_launchdt() const {
  return launchdt_.Get();
}
inline void RetSatelliteInfoElement::_internal_set_launchdt(const std::string& value) {
  
  launchdt_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::_internal_mutable_launchdt() {
  
  return launchdt_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::release_launchdt() {
  // @@protoc_insertion_point(field_release:RetSatelliteInfoElement.launchDt)
  return launchdt_.Release();
}
inline void RetSatelliteInfoElement::set_allocated_launchdt(std::string* launchdt) {
  if (launchdt != nullptr) {
    
  } else {
    
  }
  launchdt_.SetAllocated(launchdt, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (launchdt_.IsDefault()) {
    launchdt_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteInfoElement.launchDt)
}

// string launchPlace = 10;
inline void RetSatelliteInfoElement::clear_launchplace() {
  launchplace_.ClearToEmpty();
}
inline const std::string& RetSatelliteInfoElement::launchplace() const {
  // @@protoc_insertion_point(field_get:RetSatelliteInfoElement.launchPlace)
  return _internal_launchplace();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteInfoElement::set_launchplace(ArgT0&& arg0, ArgT... args) {
 
 launchplace_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteInfoElement.launchPlace)
}
inline std::string* RetSatelliteInfoElement::mutable_launchplace() {
  std::string* _s = _internal_mutable_launchplace();
  // @@protoc_insertion_point(field_mutable:RetSatelliteInfoElement.launchPlace)
  return _s;
}
inline const std::string& RetSatelliteInfoElement::_internal_launchplace() const {
  return launchplace_.Get();
}
inline void RetSatelliteInfoElement::_internal_set_launchplace(const std::string& value) {
  
  launchplace_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::_internal_mutable_launchplace() {
  
  return launchplace_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::release_launchplace() {
  // @@protoc_insertion_point(field_release:RetSatelliteInfoElement.launchPlace)
  return launchplace_.Release();
}
inline void RetSatelliteInfoElement::set_allocated_launchplace(std::string* launchplace) {
  if (launchplace != nullptr) {
    
  } else {
    
  }
  launchplace_.SetAllocated(launchplace, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (launchplace_.IsDefault()) {
    launchplace_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteInfoElement.launchPlace)
}

// string carrierRocket = 11;
inline void RetSatelliteInfoElement::clear_carrierrocket() {
  carrierrocket_.ClearToEmpty();
}
inline const std::string& RetSatelliteInfoElement::carrierrocket() const {
  // @@protoc_insertion_point(field_get:RetSatelliteInfoElement.carrierRocket)
  return _internal_carrierrocket();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteInfoElement::set_carrierrocket(ArgT0&& arg0, ArgT... args) {
 
 carrierrocket_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteInfoElement.carrierRocket)
}
inline std::string* RetSatelliteInfoElement::mutable_carrierrocket() {
  std::string* _s = _internal_mutable_carrierrocket();
  // @@protoc_insertion_point(field_mutable:RetSatelliteInfoElement.carrierRocket)
  return _s;
}
inline const std::string& RetSatelliteInfoElement::_internal_carrierrocket() const {
  return carrierrocket_.Get();
}
inline void RetSatelliteInfoElement::_internal_set_carrierrocket(const std::string& value) {
  
  carrierrocket_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::_internal_mutable_carrierrocket() {
  
  return carrierrocket_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::release_carrierrocket() {
  // @@protoc_insertion_point(field_release:RetSatelliteInfoElement.carrierRocket)
  return carrierrocket_.Release();
}
inline void RetSatelliteInfoElement::set_allocated_carrierrocket(std::string* carrierrocket) {
  if (carrierrocket != nullptr) {
    
  } else {
    
  }
  carrierrocket_.SetAllocated(carrierrocket, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (carrierrocket_.IsDefault()) {
    carrierrocket_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteInfoElement.carrierRocket)
}

// string ageLimit = 12;
inline void RetSatelliteInfoElement::clear_agelimit() {
  agelimit_.ClearToEmpty();
}
inline const std::string& RetSatelliteInfoElement::agelimit() const {
  // @@protoc_insertion_point(field_get:RetSatelliteInfoElement.ageLimit)
  return _internal_agelimit();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteInfoElement::set_agelimit(ArgT0&& arg0, ArgT... args) {
 
 agelimit_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteInfoElement.ageLimit)
}
inline std::string* RetSatelliteInfoElement::mutable_agelimit() {
  std::string* _s = _internal_mutable_agelimit();
  // @@protoc_insertion_point(field_mutable:RetSatelliteInfoElement.ageLimit)
  return _s;
}
inline const std::string& RetSatelliteInfoElement::_internal_agelimit() const {
  return agelimit_.Get();
}
inline void RetSatelliteInfoElement::_internal_set_agelimit(const std::string& value) {
  
  agelimit_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::_internal_mutable_agelimit() {
  
  return agelimit_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::release_agelimit() {
  // @@protoc_insertion_point(field_release:RetSatelliteInfoElement.ageLimit)
  return agelimit_.Release();
}
inline void RetSatelliteInfoElement::set_allocated_agelimit(std::string* agelimit) {
  if (agelimit != nullptr) {
    
  } else {
    
  }
  agelimit_.SetAllocated(agelimit, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (agelimit_.IsDefault()) {
    agelimit_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteInfoElement.ageLimit)
}

// string manager = 13;
inline void RetSatelliteInfoElement::clear_manager() {
  manager_.ClearToEmpty();
}
inline const std::string& RetSatelliteInfoElement::manager() const {
  // @@protoc_insertion_point(field_get:RetSatelliteInfoElement.manager)
  return _internal_manager();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteInfoElement::set_manager(ArgT0&& arg0, ArgT... args) {
 
 manager_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteInfoElement.manager)
}
inline std::string* RetSatelliteInfoElement::mutable_manager() {
  std::string* _s = _internal_mutable_manager();
  // @@protoc_insertion_point(field_mutable:RetSatelliteInfoElement.manager)
  return _s;
}
inline const std::string& RetSatelliteInfoElement::_internal_manager() const {
  return manager_.Get();
}
inline void RetSatelliteInfoElement::_internal_set_manager(const std::string& value) {
  
  manager_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::_internal_mutable_manager() {
  
  return manager_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::release_manager() {
  // @@protoc_insertion_point(field_release:RetSatelliteInfoElement.manager)
  return manager_.Release();
}
inline void RetSatelliteInfoElement::set_allocated_manager(std::string* manager) {
  if (manager != nullptr) {
    
  } else {
    
  }
  manager_.SetAllocated(manager, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (manager_.IsDefault()) {
    manager_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteInfoElement.manager)
}

// string contractor = 14;
inline void RetSatelliteInfoElement::clear_contractor() {
  contractor_.ClearToEmpty();
}
inline const std::string& RetSatelliteInfoElement::contractor() const {
  // @@protoc_insertion_point(field_get:RetSatelliteInfoElement.contractor)
  return _internal_contractor();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteInfoElement::set_contractor(ArgT0&& arg0, ArgT... args) {
 
 contractor_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteInfoElement.contractor)
}
inline std::string* RetSatelliteInfoElement::mutable_contractor() {
  std::string* _s = _internal_mutable_contractor();
  // @@protoc_insertion_point(field_mutable:RetSatelliteInfoElement.contractor)
  return _s;
}
inline const std::string& RetSatelliteInfoElement::_internal_contractor() const {
  return contractor_.Get();
}
inline void RetSatelliteInfoElement::_internal_set_contractor(const std::string& value) {
  
  contractor_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::_internal_mutable_contractor() {
  
  return contractor_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::release_contractor() {
  // @@protoc_insertion_point(field_release:RetSatelliteInfoElement.contractor)
  return contractor_.Release();
}
inline void RetSatelliteInfoElement::set_allocated_contractor(std::string* contractor) {
  if (contractor != nullptr) {
    
  } else {
    
  }
  contractor_.SetAllocated(contractor, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (contractor_.IsDefault()) {
    contractor_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteInfoElement.contractor)
}

// string platform = 15;
inline void RetSatelliteInfoElement::clear_platform() {
  platform_.ClearToEmpty();
}
inline const std::string& RetSatelliteInfoElement::platform() const {
  // @@protoc_insertion_point(field_get:RetSatelliteInfoElement.platform)
  return _internal_platform();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteInfoElement::set_platform(ArgT0&& arg0, ArgT... args) {
 
 platform_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteInfoElement.platform)
}
inline std::string* RetSatelliteInfoElement::mutable_platform() {
  std::string* _s = _internal_mutable_platform();
  // @@protoc_insertion_point(field_mutable:RetSatelliteInfoElement.platform)
  return _s;
}
inline const std::string& RetSatelliteInfoElement::_internal_platform() const {
  return platform_.Get();
}
inline void RetSatelliteInfoElement::_internal_set_platform(const std::string& value) {
  
  platform_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::_internal_mutable_platform() {
  
  return platform_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::release_platform() {
  // @@protoc_insertion_point(field_release:RetSatelliteInfoElement.platform)
  return platform_.Release();
}
inline void RetSatelliteInfoElement::set_allocated_platform(std::string* platform) {
  if (platform != nullptr) {
    
  } else {
    
  }
  platform_.SetAllocated(platform, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (platform_.IsDefault()) {
    platform_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteInfoElement.platform)
}

// string payload = 16;
inline void RetSatelliteInfoElement::clear_payload() {
  payload_.ClearToEmpty();
}
inline const std::string& RetSatelliteInfoElement::payload() const {
  // @@protoc_insertion_point(field_get:RetSatelliteInfoElement.payload)
  return _internal_payload();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteInfoElement::set_payload(ArgT0&& arg0, ArgT... args) {
 
 payload_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteInfoElement.payload)
}
inline std::string* RetSatelliteInfoElement::mutable_payload() {
  std::string* _s = _internal_mutable_payload();
  // @@protoc_insertion_point(field_mutable:RetSatelliteInfoElement.payload)
  return _s;
}
inline const std::string& RetSatelliteInfoElement::_internal_payload() const {
  return payload_.Get();
}
inline void RetSatelliteInfoElement::_internal_set_payload(const std::string& value) {
  
  payload_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::_internal_mutable_payload() {
  
  return payload_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::release_payload() {
  // @@protoc_insertion_point(field_release:RetSatelliteInfoElement.payload)
  return payload_.Release();
}
inline void RetSatelliteInfoElement::set_allocated_payload(std::string* payload) {
  if (payload != nullptr) {
    
  } else {
    
  }
  payload_.SetAllocated(payload, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (payload_.IsDefault()) {
    payload_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteInfoElement.payload)
}

// string booster = 17;
inline void RetSatelliteInfoElement::clear_booster() {
  booster_.ClearToEmpty();
}
inline const std::string& RetSatelliteInfoElement::booster() const {
  // @@protoc_insertion_point(field_get:RetSatelliteInfoElement.booster)
  return _internal_booster();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteInfoElement::set_booster(ArgT0&& arg0, ArgT... args) {
 
 booster_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteInfoElement.booster)
}
inline std::string* RetSatelliteInfoElement::mutable_booster() {
  std::string* _s = _internal_mutable_booster();
  // @@protoc_insertion_point(field_mutable:RetSatelliteInfoElement.booster)
  return _s;
}
inline const std::string& RetSatelliteInfoElement::_internal_booster() const {
  return booster_.Get();
}
inline void RetSatelliteInfoElement::_internal_set_booster(const std::string& value) {
  
  booster_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::_internal_mutable_booster() {
  
  return booster_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::release_booster() {
  // @@protoc_insertion_point(field_release:RetSatelliteInfoElement.booster)
  return booster_.Release();
}
inline void RetSatelliteInfoElement::set_allocated_booster(std::string* booster) {
  if (booster != nullptr) {
    
  } else {
    
  }
  booster_.SetAllocated(booster, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (booster_.IsDefault()) {
    booster_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteInfoElement.booster)
}

// string power = 18;
inline void RetSatelliteInfoElement::clear_power() {
  power_.ClearToEmpty();
}
inline const std::string& RetSatelliteInfoElement::power() const {
  // @@protoc_insertion_point(field_get:RetSatelliteInfoElement.power)
  return _internal_power();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteInfoElement::set_power(ArgT0&& arg0, ArgT... args) {
 
 power_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteInfoElement.power)
}
inline std::string* RetSatelliteInfoElement::mutable_power() {
  std::string* _s = _internal_mutable_power();
  // @@protoc_insertion_point(field_mutable:RetSatelliteInfoElement.power)
  return _s;
}
inline const std::string& RetSatelliteInfoElement::_internal_power() const {
  return power_.Get();
}
inline void RetSatelliteInfoElement::_internal_set_power(const std::string& value) {
  
  power_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::_internal_mutable_power() {
  
  return power_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::release_power() {
  // @@protoc_insertion_point(field_release:RetSatelliteInfoElement.power)
  return power_.Release();
}
inline void RetSatelliteInfoElement::set_allocated_power(std::string* power) {
  if (power != nullptr) {
    
  } else {
    
  }
  power_.SetAllocated(power, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (power_.IsDefault()) {
    power_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteInfoElement.power)
}

// string mass = 19;
inline void RetSatelliteInfoElement::clear_mass() {
  mass_.ClearToEmpty();
}
inline const std::string& RetSatelliteInfoElement::mass() const {
  // @@protoc_insertion_point(field_get:RetSatelliteInfoElement.mass)
  return _internal_mass();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteInfoElement::set_mass(ArgT0&& arg0, ArgT... args) {
 
 mass_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteInfoElement.mass)
}
inline std::string* RetSatelliteInfoElement::mutable_mass() {
  std::string* _s = _internal_mutable_mass();
  // @@protoc_insertion_point(field_mutable:RetSatelliteInfoElement.mass)
  return _s;
}
inline const std::string& RetSatelliteInfoElement::_internal_mass() const {
  return mass_.Get();
}
inline void RetSatelliteInfoElement::_internal_set_mass(const std::string& value) {
  
  mass_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::_internal_mutable_mass() {
  
  return mass_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::release_mass() {
  // @@protoc_insertion_point(field_release:RetSatelliteInfoElement.mass)
  return mass_.Release();
}
inline void RetSatelliteInfoElement::set_allocated_mass(std::string* mass) {
  if (mass != nullptr) {
    
  } else {
    
  }
  mass_.SetAllocated(mass, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (mass_.IsDefault()) {
    mass_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteInfoElement.mass)
}

// string orbitType = 20;
inline void RetSatelliteInfoElement::clear_orbittype() {
  orbittype_.ClearToEmpty();
}
inline const std::string& RetSatelliteInfoElement::orbittype() const {
  // @@protoc_insertion_point(field_get:RetSatelliteInfoElement.orbitType)
  return _internal_orbittype();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteInfoElement::set_orbittype(ArgT0&& arg0, ArgT... args) {
 
 orbittype_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteInfoElement.orbitType)
}
inline std::string* RetSatelliteInfoElement::mutable_orbittype() {
  std::string* _s = _internal_mutable_orbittype();
  // @@protoc_insertion_point(field_mutable:RetSatelliteInfoElement.orbitType)
  return _s;
}
inline const std::string& RetSatelliteInfoElement::_internal_orbittype() const {
  return orbittype_.Get();
}
inline void RetSatelliteInfoElement::_internal_set_orbittype(const std::string& value) {
  
  orbittype_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::_internal_mutable_orbittype() {
  
  return orbittype_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::release_orbittype() {
  // @@protoc_insertion_point(field_release:RetSatelliteInfoElement.orbitType)
  return orbittype_.Release();
}
inline void RetSatelliteInfoElement::set_allocated_orbittype(std::string* orbittype) {
  if (orbittype != nullptr) {
    
  } else {
    
  }
  orbittype_.SetAllocated(orbittype, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (orbittype_.IsDefault()) {
    orbittype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteInfoElement.orbitType)
}

// string remark = 21;
inline void RetSatelliteInfoElement::clear_remark() {
  remark_.ClearToEmpty();
}
inline const std::string& RetSatelliteInfoElement::remark() const {
  // @@protoc_insertion_point(field_get:RetSatelliteInfoElement.remark)
  return _internal_remark();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteInfoElement::set_remark(ArgT0&& arg0, ArgT... args) {
 
 remark_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteInfoElement.remark)
}
inline std::string* RetSatelliteInfoElement::mutable_remark() {
  std::string* _s = _internal_mutable_remark();
  // @@protoc_insertion_point(field_mutable:RetSatelliteInfoElement.remark)
  return _s;
}
inline const std::string& RetSatelliteInfoElement::_internal_remark() const {
  return remark_.Get();
}
inline void RetSatelliteInfoElement::_internal_set_remark(const std::string& value) {
  
  remark_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::_internal_mutable_remark() {
  
  return remark_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteInfoElement::release_remark() {
  // @@protoc_insertion_point(field_release:RetSatelliteInfoElement.remark)
  return remark_.Release();
}
inline void RetSatelliteInfoElement::set_allocated_remark(std::string* remark) {
  if (remark != nullptr) {
    
  } else {
    
  }
  remark_.SetAllocated(remark, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (remark_.IsDefault()) {
    remark_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteInfoElement.remark)
}

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

// ReqSatelliteParamUpdate

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

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

// string feedSource = 3;
inline void ReqSatelliteParamUpdate::clear_feedsource() {
  feedsource_.ClearToEmpty();
}
inline const std::string& ReqSatelliteParamUpdate::feedsource() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteParamUpdate.feedSource)
  return _internal_feedsource();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqSatelliteParamUpdate::set_feedsource(ArgT0&& arg0, ArgT... args) {
 
 feedsource_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqSatelliteParamUpdate.feedSource)
}
inline std::string* ReqSatelliteParamUpdate::mutable_feedsource() {
  std::string* _s = _internal_mutable_feedsource();
  // @@protoc_insertion_point(field_mutable:ReqSatelliteParamUpdate.feedSource)
  return _s;
}
inline const std::string& ReqSatelliteParamUpdate::_internal_feedsource() const {
  return feedsource_.Get();
}
inline void ReqSatelliteParamUpdate::_internal_set_feedsource(const std::string& value) {
  
  feedsource_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqSatelliteParamUpdate::_internal_mutable_feedsource() {
  
  return feedsource_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqSatelliteParamUpdate::release_feedsource() {
  // @@protoc_insertion_point(field_release:ReqSatelliteParamUpdate.feedSource)
  return feedsource_.Release();
}
inline void ReqSatelliteParamUpdate::set_allocated_feedsource(std::string* feedsource) {
  if (feedsource != nullptr) {
    
  } else {
    
  }
  feedsource_.SetAllocated(feedsource, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (feedsource_.IsDefault()) {
    feedsource_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqSatelliteParamUpdate.feedSource)
}

// string polarization = 4;
inline void ReqSatelliteParamUpdate::clear_polarization() {
  polarization_.ClearToEmpty();
}
inline const std::string& ReqSatelliteParamUpdate::polarization() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteParamUpdate.polarization)
  return _internal_polarization();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqSatelliteParamUpdate::set_polarization(ArgT0&& arg0, ArgT... args) {
 
 polarization_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqSatelliteParamUpdate.polarization)
}
inline std::string* ReqSatelliteParamUpdate::mutable_polarization() {
  std::string* _s = _internal_mutable_polarization();
  // @@protoc_insertion_point(field_mutable:ReqSatelliteParamUpdate.polarization)
  return _s;
}
inline const std::string& ReqSatelliteParamUpdate::_internal_polarization() const {
  return polarization_.Get();
}
inline void ReqSatelliteParamUpdate::_internal_set_polarization(const std::string& value) {
  
  polarization_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqSatelliteParamUpdate::_internal_mutable_polarization() {
  
  return polarization_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqSatelliteParamUpdate::release_polarization() {
  // @@protoc_insertion_point(field_release:ReqSatelliteParamUpdate.polarization)
  return polarization_.Release();
}
inline void ReqSatelliteParamUpdate::set_allocated_polarization(std::string* polarization) {
  if (polarization != nullptr) {
    
  } else {
    
  }
  polarization_.SetAllocated(polarization, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (polarization_.IsDefault()) {
    polarization_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqSatelliteParamUpdate.polarization)
}

// double trackAcceptFreq = 5;
inline void ReqSatelliteParamUpdate::clear_trackacceptfreq() {
  trackacceptfreq_ = 0;
}
inline double ReqSatelliteParamUpdate::_internal_trackacceptfreq() const {
  return trackacceptfreq_;
}
inline double ReqSatelliteParamUpdate::trackacceptfreq() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteParamUpdate.trackAcceptFreq)
  return _internal_trackacceptfreq();
}
inline void ReqSatelliteParamUpdate::_internal_set_trackacceptfreq(double value) {
  
  trackacceptfreq_ = value;
}
inline void ReqSatelliteParamUpdate::set_trackacceptfreq(double value) {
  _internal_set_trackacceptfreq(value);
  // @@protoc_insertion_point(field_set:ReqSatelliteParamUpdate.trackAcceptFreq)
}

// double trackAcceptThreshold = 6;
inline void ReqSatelliteParamUpdate::clear_trackacceptthreshold() {
  trackacceptthreshold_ = 0;
}
inline double ReqSatelliteParamUpdate::_internal_trackacceptthreshold() const {
  return trackacceptthreshold_;
}
inline double ReqSatelliteParamUpdate::trackacceptthreshold() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteParamUpdate.trackAcceptThreshold)
  return _internal_trackacceptthreshold();
}
inline void ReqSatelliteParamUpdate::_internal_set_trackacceptthreshold(double value) {
  
  trackacceptthreshold_ = value;
}
inline void ReqSatelliteParamUpdate::set_trackacceptthreshold(double value) {
  _internal_set_trackacceptthreshold(value);
  // @@protoc_insertion_point(field_set:ReqSatelliteParamUpdate.trackAcceptThreshold)
}

// bool track = 7;
inline void ReqSatelliteParamUpdate::clear_track() {
  track_ = false;
}
inline bool ReqSatelliteParamUpdate::_internal_track() const {
  return track_;
}
inline bool ReqSatelliteParamUpdate::track() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteParamUpdate.track)
  return _internal_track();
}
inline void ReqSatelliteParamUpdate::_internal_set_track(bool value) {
  
  track_ = value;
}
inline void ReqSatelliteParamUpdate::set_track(bool value) {
  _internal_set_track(value);
  // @@protoc_insertion_point(field_set:ReqSatelliteParamUpdate.track)
}

// int32 sampleChannel = 8;
inline void ReqSatelliteParamUpdate::clear_samplechannel() {
  samplechannel_ = 0;
}
inline int32_t ReqSatelliteParamUpdate::_internal_samplechannel() const {
  return samplechannel_;
}
inline int32_t ReqSatelliteParamUpdate::samplechannel() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteParamUpdate.sampleChannel)
  return _internal_samplechannel();
}
inline void ReqSatelliteParamUpdate::_internal_set_samplechannel(int32_t value) {
  
  samplechannel_ = value;
}
inline void ReqSatelliteParamUpdate::set_samplechannel(int32_t value) {
  _internal_set_samplechannel(value);
  // @@protoc_insertion_point(field_set:ReqSatelliteParamUpdate.sampleChannel)
}

// int32 rfAttenuation = 9;
inline void ReqSatelliteParamUpdate::clear_rfattenuation() {
  rfattenuation_ = 0;
}
inline int32_t ReqSatelliteParamUpdate::_internal_rfattenuation() const {
  return rfattenuation_;
}
inline int32_t ReqSatelliteParamUpdate::rfattenuation() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteParamUpdate.rfAttenuation)
  return _internal_rfattenuation();
}
inline void ReqSatelliteParamUpdate::_internal_set_rfattenuation(int32_t value) {
  
  rfattenuation_ = value;
}
inline void ReqSatelliteParamUpdate::set_rfattenuation(int32_t value) {
  _internal_set_rfattenuation(value);
  // @@protoc_insertion_point(field_set:ReqSatelliteParamUpdate.rfAttenuation)
}

// int32 midFreqGain = 10;
inline void ReqSatelliteParamUpdate::clear_midfreqgain() {
  midfreqgain_ = 0;
}
inline int32_t ReqSatelliteParamUpdate::_internal_midfreqgain() const {
  return midfreqgain_;
}
inline int32_t ReqSatelliteParamUpdate::midfreqgain() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteParamUpdate.midFreqGain)
  return _internal_midfreqgain();
}
inline void ReqSatelliteParamUpdate::_internal_set_midfreqgain(int32_t value) {
  
  midfreqgain_ = value;
}
inline void ReqSatelliteParamUpdate::set_midfreqgain(int32_t value) {
  _internal_set_midfreqgain(value);
  // @@protoc_insertion_point(field_set:ReqSatelliteParamUpdate.midFreqGain)
}

// double centerRadioFreq = 11;
inline void ReqSatelliteParamUpdate::clear_centerradiofreq() {
  centerradiofreq_ = 0;
}
inline double ReqSatelliteParamUpdate::_internal_centerradiofreq() const {
  return centerradiofreq_;
}
inline double ReqSatelliteParamUpdate::centerradiofreq() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteParamUpdate.centerRadioFreq)
  return _internal_centerradiofreq();
}
inline void ReqSatelliteParamUpdate::_internal_set_centerradiofreq(double value) {
  
  centerradiofreq_ = value;
}
inline void ReqSatelliteParamUpdate::set_centerradiofreq(double value) {
  _internal_set_centerradiofreq(value);
  // @@protoc_insertion_point(field_set:ReqSatelliteParamUpdate.centerRadioFreq)
}

// int32 checkSignalBound = 12;
inline void ReqSatelliteParamUpdate::clear_checksignalbound() {
  checksignalbound_ = 0;
}
inline int32_t ReqSatelliteParamUpdate::_internal_checksignalbound() const {
  return checksignalbound_;
}
inline int32_t ReqSatelliteParamUpdate::checksignalbound() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteParamUpdate.checkSignalBound)
  return _internal_checksignalbound();
}
inline void ReqSatelliteParamUpdate::_internal_set_checksignalbound(int32_t value) {
  
  checksignalbound_ = value;
}
inline void ReqSatelliteParamUpdate::set_checksignalbound(int32_t value) {
  _internal_set_checksignalbound(value);
  // @@protoc_insertion_point(field_set:ReqSatelliteParamUpdate.checkSignalBound)
}

// int32 sampleRate = 13;
inline void ReqSatelliteParamUpdate::clear_samplerate() {
  samplerate_ = 0;
}
inline int32_t ReqSatelliteParamUpdate::_internal_samplerate() const {
  return samplerate_;
}
inline int32_t ReqSatelliteParamUpdate::samplerate() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteParamUpdate.sampleRate)
  return _internal_samplerate();
}
inline void ReqSatelliteParamUpdate::_internal_set_samplerate(int32_t value) {
  
  samplerate_ = value;
}
inline void ReqSatelliteParamUpdate::set_samplerate(int32_t value) {
  _internal_set_samplerate(value);
  // @@protoc_insertion_point(field_set:ReqSatelliteParamUpdate.sampleRate)
}

// int32 checkSignalRange = 14;
inline void ReqSatelliteParamUpdate::clear_checksignalrange() {
  checksignalrange_ = 0;
}
inline int32_t ReqSatelliteParamUpdate::_internal_checksignalrange() const {
  return checksignalrange_;
}
inline int32_t ReqSatelliteParamUpdate::checksignalrange() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteParamUpdate.checkSignalRange)
  return _internal_checksignalrange();
}
inline void ReqSatelliteParamUpdate::_internal_set_checksignalrange(int32_t value) {
  
  checksignalrange_ = value;
}
inline void ReqSatelliteParamUpdate::set_checksignalrange(int32_t value) {
  _internal_set_checksignalrange(value);
  // @@protoc_insertion_point(field_set:ReqSatelliteParamUpdate.checkSignalRange)
}

// int32 signalAnalyseType = 15;
inline void ReqSatelliteParamUpdate::clear_signalanalysetype() {
  signalanalysetype_ = 0;
}
inline int32_t ReqSatelliteParamUpdate::_internal_signalanalysetype() const {
  return signalanalysetype_;
}
inline int32_t ReqSatelliteParamUpdate::signalanalysetype() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteParamUpdate.signalAnalyseType)
  return _internal_signalanalysetype();
}
inline void ReqSatelliteParamUpdate::_internal_set_signalanalysetype(int32_t value) {
  
  signalanalysetype_ = value;
}
inline void ReqSatelliteParamUpdate::set_signalanalysetype(int32_t value) {
  _internal_set_signalanalysetype(value);
  // @@protoc_insertion_point(field_set:ReqSatelliteParamUpdate.signalAnalyseType)
}

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

// RetSatelliteParamElement

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

// string feedSource = 3;
inline void RetSatelliteParamElement::clear_feedsource() {
  feedsource_.ClearToEmpty();
}
inline const std::string& RetSatelliteParamElement::feedsource() const {
  // @@protoc_insertion_point(field_get:RetSatelliteParamElement.feedSource)
  return _internal_feedsource();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteParamElement::set_feedsource(ArgT0&& arg0, ArgT... args) {
 
 feedsource_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteParamElement.feedSource)
}
inline std::string* RetSatelliteParamElement::mutable_feedsource() {
  std::string* _s = _internal_mutable_feedsource();
  // @@protoc_insertion_point(field_mutable:RetSatelliteParamElement.feedSource)
  return _s;
}
inline const std::string& RetSatelliteParamElement::_internal_feedsource() const {
  return feedsource_.Get();
}
inline void RetSatelliteParamElement::_internal_set_feedsource(const std::string& value) {
  
  feedsource_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteParamElement::_internal_mutable_feedsource() {
  
  return feedsource_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteParamElement::release_feedsource() {
  // @@protoc_insertion_point(field_release:RetSatelliteParamElement.feedSource)
  return feedsource_.Release();
}
inline void RetSatelliteParamElement::set_allocated_feedsource(std::string* feedsource) {
  if (feedsource != nullptr) {
    
  } else {
    
  }
  feedsource_.SetAllocated(feedsource, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (feedsource_.IsDefault()) {
    feedsource_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteParamElement.feedSource)
}

// string polarization = 4;
inline void RetSatelliteParamElement::clear_polarization() {
  polarization_.ClearToEmpty();
}
inline const std::string& RetSatelliteParamElement::polarization() const {
  // @@protoc_insertion_point(field_get:RetSatelliteParamElement.polarization)
  return _internal_polarization();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSatelliteParamElement::set_polarization(ArgT0&& arg0, ArgT... args) {
 
 polarization_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSatelliteParamElement.polarization)
}
inline std::string* RetSatelliteParamElement::mutable_polarization() {
  std::string* _s = _internal_mutable_polarization();
  // @@protoc_insertion_point(field_mutable:RetSatelliteParamElement.polarization)
  return _s;
}
inline const std::string& RetSatelliteParamElement::_internal_polarization() const {
  return polarization_.Get();
}
inline void RetSatelliteParamElement::_internal_set_polarization(const std::string& value) {
  
  polarization_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSatelliteParamElement::_internal_mutable_polarization() {
  
  return polarization_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSatelliteParamElement::release_polarization() {
  // @@protoc_insertion_point(field_release:RetSatelliteParamElement.polarization)
  return polarization_.Release();
}
inline void RetSatelliteParamElement::set_allocated_polarization(std::string* polarization) {
  if (polarization != nullptr) {
    
  } else {
    
  }
  polarization_.SetAllocated(polarization, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (polarization_.IsDefault()) {
    polarization_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSatelliteParamElement.polarization)
}

// double trackAcceptFreq = 5;
inline void RetSatelliteParamElement::clear_trackacceptfreq() {
  trackacceptfreq_ = 0;
}
inline double RetSatelliteParamElement::_internal_trackacceptfreq() const {
  return trackacceptfreq_;
}
inline double RetSatelliteParamElement::trackacceptfreq() const {
  // @@protoc_insertion_point(field_get:RetSatelliteParamElement.trackAcceptFreq)
  return _internal_trackacceptfreq();
}
inline void RetSatelliteParamElement::_internal_set_trackacceptfreq(double value) {
  
  trackacceptfreq_ = value;
}
inline void RetSatelliteParamElement::set_trackacceptfreq(double value) {
  _internal_set_trackacceptfreq(value);
  // @@protoc_insertion_point(field_set:RetSatelliteParamElement.trackAcceptFreq)
}

// double trackAcceptThreshold = 6;
inline void RetSatelliteParamElement::clear_trackacceptthreshold() {
  trackacceptthreshold_ = 0;
}
inline double RetSatelliteParamElement::_internal_trackacceptthreshold() const {
  return trackacceptthreshold_;
}
inline double RetSatelliteParamElement::trackacceptthreshold() const {
  // @@protoc_insertion_point(field_get:RetSatelliteParamElement.trackAcceptThreshold)
  return _internal_trackacceptthreshold();
}
inline void RetSatelliteParamElement::_internal_set_trackacceptthreshold(double value) {
  
  trackacceptthreshold_ = value;
}
inline void RetSatelliteParamElement::set_trackacceptthreshold(double value) {
  _internal_set_trackacceptthreshold(value);
  // @@protoc_insertion_point(field_set:RetSatelliteParamElement.trackAcceptThreshold)
}

// bool track = 7;
inline void RetSatelliteParamElement::clear_track() {
  track_ = false;
}
inline bool RetSatelliteParamElement::_internal_track() const {
  return track_;
}
inline bool RetSatelliteParamElement::track() const {
  // @@protoc_insertion_point(field_get:RetSatelliteParamElement.track)
  return _internal_track();
}
inline void RetSatelliteParamElement::_internal_set_track(bool value) {
  
  track_ = value;
}
inline void RetSatelliteParamElement::set_track(bool value) {
  _internal_set_track(value);
  // @@protoc_insertion_point(field_set:RetSatelliteParamElement.track)
}

// int32 sampleChannel = 8;
inline void RetSatelliteParamElement::clear_samplechannel() {
  samplechannel_ = 0;
}
inline int32_t RetSatelliteParamElement::_internal_samplechannel() const {
  return samplechannel_;
}
inline int32_t RetSatelliteParamElement::samplechannel() const {
  // @@protoc_insertion_point(field_get:RetSatelliteParamElement.sampleChannel)
  return _internal_samplechannel();
}
inline void RetSatelliteParamElement::_internal_set_samplechannel(int32_t value) {
  
  samplechannel_ = value;
}
inline void RetSatelliteParamElement::set_samplechannel(int32_t value) {
  _internal_set_samplechannel(value);
  // @@protoc_insertion_point(field_set:RetSatelliteParamElement.sampleChannel)
}

// int32 rfAttenuation = 9;
inline void RetSatelliteParamElement::clear_rfattenuation() {
  rfattenuation_ = 0;
}
inline int32_t RetSatelliteParamElement::_internal_rfattenuation() const {
  return rfattenuation_;
}
inline int32_t RetSatelliteParamElement::rfattenuation() const {
  // @@protoc_insertion_point(field_get:RetSatelliteParamElement.rfAttenuation)
  return _internal_rfattenuation();
}
inline void RetSatelliteParamElement::_internal_set_rfattenuation(int32_t value) {
  
  rfattenuation_ = value;
}
inline void RetSatelliteParamElement::set_rfattenuation(int32_t value) {
  _internal_set_rfattenuation(value);
  // @@protoc_insertion_point(field_set:RetSatelliteParamElement.rfAttenuation)
}

// int32 midFreqGain = 10;
inline void RetSatelliteParamElement::clear_midfreqgain() {
  midfreqgain_ = 0;
}
inline int32_t RetSatelliteParamElement::_internal_midfreqgain() const {
  return midfreqgain_;
}
inline int32_t RetSatelliteParamElement::midfreqgain() const {
  // @@protoc_insertion_point(field_get:RetSatelliteParamElement.midFreqGain)
  return _internal_midfreqgain();
}
inline void RetSatelliteParamElement::_internal_set_midfreqgain(int32_t value) {
  
  midfreqgain_ = value;
}
inline void RetSatelliteParamElement::set_midfreqgain(int32_t value) {
  _internal_set_midfreqgain(value);
  // @@protoc_insertion_point(field_set:RetSatelliteParamElement.midFreqGain)
}

// double centerRadioFreq = 11;
inline void RetSatelliteParamElement::clear_centerradiofreq() {
  centerradiofreq_ = 0;
}
inline double RetSatelliteParamElement::_internal_centerradiofreq() const {
  return centerradiofreq_;
}
inline double RetSatelliteParamElement::centerradiofreq() const {
  // @@protoc_insertion_point(field_get:RetSatelliteParamElement.centerRadioFreq)
  return _internal_centerradiofreq();
}
inline void RetSatelliteParamElement::_internal_set_centerradiofreq(double value) {
  
  centerradiofreq_ = value;
}
inline void RetSatelliteParamElement::set_centerradiofreq(double value) {
  _internal_set_centerradiofreq(value);
  // @@protoc_insertion_point(field_set:RetSatelliteParamElement.centerRadioFreq)
}

// int32 checkSignalBound = 12;
inline void RetSatelliteParamElement::clear_checksignalbound() {
  checksignalbound_ = 0;
}
inline int32_t RetSatelliteParamElement::_internal_checksignalbound() const {
  return checksignalbound_;
}
inline int32_t RetSatelliteParamElement::checksignalbound() const {
  // @@protoc_insertion_point(field_get:RetSatelliteParamElement.checkSignalBound)
  return _internal_checksignalbound();
}
inline void RetSatelliteParamElement::_internal_set_checksignalbound(int32_t value) {
  
  checksignalbound_ = value;
}
inline void RetSatelliteParamElement::set_checksignalbound(int32_t value) {
  _internal_set_checksignalbound(value);
  // @@protoc_insertion_point(field_set:RetSatelliteParamElement.checkSignalBound)
}

// int32 sampleRate = 13;
inline void RetSatelliteParamElement::clear_samplerate() {
  samplerate_ = 0;
}
inline int32_t RetSatelliteParamElement::_internal_samplerate() const {
  return samplerate_;
}
inline int32_t RetSatelliteParamElement::samplerate() const {
  // @@protoc_insertion_point(field_get:RetSatelliteParamElement.sampleRate)
  return _internal_samplerate();
}
inline void RetSatelliteParamElement::_internal_set_samplerate(int32_t value) {
  
  samplerate_ = value;
}
inline void RetSatelliteParamElement::set_samplerate(int32_t value) {
  _internal_set_samplerate(value);
  // @@protoc_insertion_point(field_set:RetSatelliteParamElement.sampleRate)
}

// int32 checkSignalRange = 14;
inline void RetSatelliteParamElement::clear_checksignalrange() {
  checksignalrange_ = 0;
}
inline int32_t RetSatelliteParamElement::_internal_checksignalrange() const {
  return checksignalrange_;
}
inline int32_t RetSatelliteParamElement::checksignalrange() const {
  // @@protoc_insertion_point(field_get:RetSatelliteParamElement.checkSignalRange)
  return _internal_checksignalrange();
}
inline void RetSatelliteParamElement::_internal_set_checksignalrange(int32_t value) {
  
  checksignalrange_ = value;
}
inline void RetSatelliteParamElement::set_checksignalrange(int32_t value) {
  _internal_set_checksignalrange(value);
  // @@protoc_insertion_point(field_set:RetSatelliteParamElement.checkSignalRange)
}

// int32 signalAnalyseType = 15;
inline void RetSatelliteParamElement::clear_signalanalysetype() {
  signalanalysetype_ = 0;
}
inline int32_t RetSatelliteParamElement::_internal_signalanalysetype() const {
  return signalanalysetype_;
}
inline int32_t RetSatelliteParamElement::signalanalysetype() const {
  // @@protoc_insertion_point(field_get:RetSatelliteParamElement.signalAnalyseType)
  return _internal_signalanalysetype();
}
inline void RetSatelliteParamElement::_internal_set_signalanalysetype(int32_t value) {
  
  signalanalysetype_ = value;
}
inline void RetSatelliteParamElement::set_signalanalysetype(int32_t value) {
  _internal_set_signalanalysetype(value);
  // @@protoc_insertion_point(field_set:RetSatelliteParamElement.signalAnalyseType)
}

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

// ReqSatelliteFind

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

// string norad = 2;
inline void ReqSatelliteFind::clear_norad() {
  norad_.ClearToEmpty();
}
inline const std::string& ReqSatelliteFind::norad() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteFind.norad)
  return _internal_norad();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqSatelliteFind::set_norad(ArgT0&& arg0, ArgT... args) {
 
 norad_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqSatelliteFind.norad)
}
inline std::string* ReqSatelliteFind::mutable_norad() {
  std::string* _s = _internal_mutable_norad();
  // @@protoc_insertion_point(field_mutable:ReqSatelliteFind.norad)
  return _s;
}
inline const std::string& ReqSatelliteFind::_internal_norad() const {
  return norad_.Get();
}
inline void ReqSatelliteFind::_internal_set_norad(const std::string& value) {
  
  norad_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqSatelliteFind::_internal_mutable_norad() {
  
  return norad_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqSatelliteFind::release_norad() {
  // @@protoc_insertion_point(field_release:ReqSatelliteFind.norad)
  return norad_.Release();
}
inline void ReqSatelliteFind::set_allocated_norad(std::string* norad) {
  if (norad != nullptr) {
    
  } else {
    
  }
  norad_.SetAllocated(norad, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (norad_.IsDefault()) {
    norad_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqSatelliteFind.norad)
}

// repeated string element = 3;
inline int ReqSatelliteFind::_internal_element_size() const {
  return element_.size();
}
inline int ReqSatelliteFind::element_size() const {
  return _internal_element_size();
}
inline void ReqSatelliteFind::clear_element() {
  element_.Clear();
}
inline std::string* ReqSatelliteFind::add_element() {
  std::string* _s = _internal_add_element();
  // @@protoc_insertion_point(field_add_mutable:ReqSatelliteFind.element)
  return _s;
}
inline const std::string& ReqSatelliteFind::_internal_element(int index) const {
  return element_.Get(index);
}
inline const std::string& ReqSatelliteFind::element(int index) const {
  // @@protoc_insertion_point(field_get:ReqSatelliteFind.element)
  return _internal_element(index);
}
inline std::string* ReqSatelliteFind::mutable_element(int index) {
  // @@protoc_insertion_point(field_mutable:ReqSatelliteFind.element)
  return element_.Mutable(index);
}
inline void ReqSatelliteFind::set_element(int index, const std::string& value) {
  element_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:ReqSatelliteFind.element)
}
inline void ReqSatelliteFind::set_element(int index, std::string&& value) {
  element_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:ReqSatelliteFind.element)
}
inline void ReqSatelliteFind::set_element(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  element_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:ReqSatelliteFind.element)
}
inline void ReqSatelliteFind::set_element(int index, const char* value, size_t size) {
  element_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:ReqSatelliteFind.element)
}
inline std::string* ReqSatelliteFind::_internal_add_element() {
  return element_.Add();
}
inline void ReqSatelliteFind::add_element(const std::string& value) {
  element_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:ReqSatelliteFind.element)
}
inline void ReqSatelliteFind::add_element(std::string&& value) {
  element_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:ReqSatelliteFind.element)
}
inline void ReqSatelliteFind::add_element(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  element_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:ReqSatelliteFind.element)
}
inline void ReqSatelliteFind::add_element(const char* value, size_t size) {
  element_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:ReqSatelliteFind.element)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
ReqSatelliteFind::element() const {
  // @@protoc_insertion_point(field_list:ReqSatelliteFind.element)
  return element_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
ReqSatelliteFind::mutable_element() {
  // @@protoc_insertion_point(field_mutable_list:ReqSatelliteFind.element)
  return &element_;
}

// .ReqSatelliteFind.RetType retType = 4;
inline void ReqSatelliteFind::clear_rettype() {
  rettype_ = 0;
}
inline ::ReqSatelliteFind_RetType ReqSatelliteFind::_internal_rettype() const {
  return static_cast< ::ReqSatelliteFind_RetType >(rettype_);
}
inline ::ReqSatelliteFind_RetType ReqSatelliteFind::rettype() const {
  // @@protoc_insertion_point(field_get:ReqSatelliteFind.retType)
  return _internal_rettype();
}
inline void ReqSatelliteFind::_internal_set_rettype(::ReqSatelliteFind_RetType value) {
  
  rettype_ = value;
}
inline void ReqSatelliteFind::set_rettype(::ReqSatelliteFind_RetType value) {
  _internal_set_rettype(value);
  // @@protoc_insertion_point(field_set:ReqSatelliteFind.retType)
}

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)


PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::ReqSatelliteFind_RetType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ReqSatelliteFind_RetType>() {
  return ::ReqSatelliteFind_RetType_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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