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

#ifndef GOOGLE_PROTOBUF_INCLUDED_mod_2dservice_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_mod_2dservice_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3020000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3020001 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_mod_2dservice_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_mod_2dservice_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_mod_2dservice_2eproto;
class ReqRetServiceElement;
struct ReqRetServiceElementDefaultTypeInternal;
extern ReqRetServiceElementDefaultTypeInternal _ReqRetServiceElement_default_instance_;
class ReqServiceFaultList;
struct ReqServiceFaultListDefaultTypeInternal;
extern ReqServiceFaultListDefaultTypeInternal _ReqServiceFaultList_default_instance_;
class RetServiceFaultElement;
struct RetServiceFaultElementDefaultTypeInternal;
extern RetServiceFaultElementDefaultTypeInternal _RetServiceFaultElement_default_instance_;
PROTOBUF_NAMESPACE_OPEN
template<> ::ReqRetServiceElement* Arena::CreateMaybeMessage<::ReqRetServiceElement>(Arena*);
template<> ::ReqServiceFaultList* Arena::CreateMaybeMessage<::ReqServiceFaultList>(Arena*);
template<> ::RetServiceFaultElement* Arena::CreateMaybeMessage<::RetServiceFaultElement>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

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

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ReqRetServiceElement";
  }
  protected:
  explicit ReqRetServiceElement(::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,
    kIpFieldNumber = 3,
    kRemarkFieldNumber = 5,
    kUpdateDtFieldNumber = 6,
    kIdFieldNumber = 1,
    kPortFieldNumber = 4,
  };
  // 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 ip = 3;
  void clear_ip();
  const std::string& ip() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_ip(ArgT0&& arg0, ArgT... args);
  std::string* mutable_ip();
  PROTOBUF_NODISCARD std::string* release_ip();
  void set_allocated_ip(std::string* ip);
  private:
  const std::string& _internal_ip() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ip(const std::string& value);
  std::string* _internal_mutable_ip();
  public:

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

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

  // 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 port = 4;
  void clear_port();
  int32_t port() const;
  void set_port(int32_t value);
  private:
  int32_t _internal_port() const;
  void _internal_set_port(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:ReqRetServiceElement)
 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 ip_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr remark_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr updatedt_;
  int32_t id_;
  int32_t port_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2dservice_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ReqServiceFaultList";
  }
  protected:
  explicit ReqServiceFaultList(::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 {
    kStartDtFieldNumber = 2,
    kEndDtFieldNumber = 3,
    kServiceIdFieldNumber = 1,
  };
  // string startDt = 2;
  void clear_startdt();
  const std::string& startdt() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_startdt(ArgT0&& arg0, ArgT... args);
  std::string* mutable_startdt();
  PROTOBUF_NODISCARD std::string* release_startdt();
  void set_allocated_startdt(std::string* startdt);
  private:
  const std::string& _internal_startdt() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_startdt(const std::string& value);
  std::string* _internal_mutable_startdt();
  public:

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

  // int32 serviceId = 1;
  void clear_serviceid();
  int32_t serviceid() const;
  void set_serviceid(int32_t value);
  private:
  int32_t _internal_serviceid() const;
  void _internal_set_serviceid(int32_t value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr startdt_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr enddt_;
  int32_t serviceid_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2dservice_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "RetServiceFaultElement";
  }
  protected:
  explicit RetServiceFaultElement(::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,
    kCodeFieldNumber = 4,
    kMsgFieldNumber = 5,
    kStartDtFieldNumber = 6,
    kEndDtFieldNumber = 7,
    kIdFieldNumber = 1,
    kGradeFieldNumber = 3,
  };
  // 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 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 msg = 5;
  void clear_msg();
  const std::string& msg() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_msg(ArgT0&& arg0, ArgT... args);
  std::string* mutable_msg();
  PROTOBUF_NODISCARD std::string* release_msg();
  void set_allocated_msg(std::string* msg);
  private:
  const std::string& _internal_msg() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_msg(const std::string& value);
  std::string* _internal_mutable_msg();
  public:

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

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

  // 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 grade = 3;
  void clear_grade();
  int32_t grade() const;
  void set_grade(int32_t value);
  private:
  int32_t _internal_grade() const;
  void _internal_set_grade(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:RetServiceFaultElement)
 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 code_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr msg_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr startdt_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr enddt_;
  int32_t id_;
  int32_t grade_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2dservice_2eproto;
};
// ===================================================================


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

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

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

// string name = 2;
inline void ReqRetServiceElement::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& ReqRetServiceElement::name() const {
  // @@protoc_insertion_point(field_get:ReqRetServiceElement.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqRetServiceElement::set_name(ArgT0&& arg0, ArgT... args) {
 
 name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqRetServiceElement.name)
}
inline std::string* ReqRetServiceElement::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:ReqRetServiceElement.name)
  return _s;
}
inline const std::string& ReqRetServiceElement::_internal_name() const {
  return name_.Get();
}
inline void ReqRetServiceElement::_internal_set_name(const std::string& value) {
  
  name_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqRetServiceElement::_internal_mutable_name() {
  
  return name_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqRetServiceElement::release_name() {
  // @@protoc_insertion_point(field_release:ReqRetServiceElement.name)
  return name_.Release();
}
inline void ReqRetServiceElement::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:ReqRetServiceElement.name)
}

// string ip = 3;
inline void ReqRetServiceElement::clear_ip() {
  ip_.ClearToEmpty();
}
inline const std::string& ReqRetServiceElement::ip() const {
  // @@protoc_insertion_point(field_get:ReqRetServiceElement.ip)
  return _internal_ip();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqRetServiceElement::set_ip(ArgT0&& arg0, ArgT... args) {
 
 ip_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqRetServiceElement.ip)
}
inline std::string* ReqRetServiceElement::mutable_ip() {
  std::string* _s = _internal_mutable_ip();
  // @@protoc_insertion_point(field_mutable:ReqRetServiceElement.ip)
  return _s;
}
inline const std::string& ReqRetServiceElement::_internal_ip() const {
  return ip_.Get();
}
inline void ReqRetServiceElement::_internal_set_ip(const std::string& value) {
  
  ip_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqRetServiceElement::_internal_mutable_ip() {
  
  return ip_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqRetServiceElement::release_ip() {
  // @@protoc_insertion_point(field_release:ReqRetServiceElement.ip)
  return ip_.Release();
}
inline void ReqRetServiceElement::set_allocated_ip(std::string* ip) {
  if (ip != nullptr) {
    
  } else {
    
  }
  ip_.SetAllocated(ip, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (ip_.IsDefault()) {
    ip_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqRetServiceElement.ip)
}

// int32 port = 4;
inline void ReqRetServiceElement::clear_port() {
  port_ = 0;
}
inline int32_t ReqRetServiceElement::_internal_port() const {
  return port_;
}
inline int32_t ReqRetServiceElement::port() const {
  // @@protoc_insertion_point(field_get:ReqRetServiceElement.port)
  return _internal_port();
}
inline void ReqRetServiceElement::_internal_set_port(int32_t value) {
  
  port_ = value;
}
inline void ReqRetServiceElement::set_port(int32_t value) {
  _internal_set_port(value);
  // @@protoc_insertion_point(field_set:ReqRetServiceElement.port)
}

// string remark = 5;
inline void ReqRetServiceElement::clear_remark() {
  remark_.ClearToEmpty();
}
inline const std::string& ReqRetServiceElement::remark() const {
  // @@protoc_insertion_point(field_get:ReqRetServiceElement.remark)
  return _internal_remark();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqRetServiceElement::set_remark(ArgT0&& arg0, ArgT... args) {
 
 remark_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqRetServiceElement.remark)
}
inline std::string* ReqRetServiceElement::mutable_remark() {
  std::string* _s = _internal_mutable_remark();
  // @@protoc_insertion_point(field_mutable:ReqRetServiceElement.remark)
  return _s;
}
inline const std::string& ReqRetServiceElement::_internal_remark() const {
  return remark_.Get();
}
inline void ReqRetServiceElement::_internal_set_remark(const std::string& value) {
  
  remark_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqRetServiceElement::_internal_mutable_remark() {
  
  return remark_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqRetServiceElement::release_remark() {
  // @@protoc_insertion_point(field_release:ReqRetServiceElement.remark)
  return remark_.Release();
}
inline void ReqRetServiceElement::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:ReqRetServiceElement.remark)
}

// string updateDt = 6;
inline void ReqRetServiceElement::clear_updatedt() {
  updatedt_.ClearToEmpty();
}
inline const std::string& ReqRetServiceElement::updatedt() const {
  // @@protoc_insertion_point(field_get:ReqRetServiceElement.updateDt)
  return _internal_updatedt();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqRetServiceElement::set_updatedt(ArgT0&& arg0, ArgT... args) {
 
 updatedt_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqRetServiceElement.updateDt)
}
inline std::string* ReqRetServiceElement::mutable_updatedt() {
  std::string* _s = _internal_mutable_updatedt();
  // @@protoc_insertion_point(field_mutable:ReqRetServiceElement.updateDt)
  return _s;
}
inline const std::string& ReqRetServiceElement::_internal_updatedt() const {
  return updatedt_.Get();
}
inline void ReqRetServiceElement::_internal_set_updatedt(const std::string& value) {
  
  updatedt_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqRetServiceElement::_internal_mutable_updatedt() {
  
  return updatedt_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqRetServiceElement::release_updatedt() {
  // @@protoc_insertion_point(field_release:ReqRetServiceElement.updateDt)
  return updatedt_.Release();
}
inline void ReqRetServiceElement::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:ReqRetServiceElement.updateDt)
}

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

// ReqServiceFaultList

// int32 serviceId = 1;
inline void ReqServiceFaultList::clear_serviceid() {
  serviceid_ = 0;
}
inline int32_t ReqServiceFaultList::_internal_serviceid() const {
  return serviceid_;
}
inline int32_t ReqServiceFaultList::serviceid() const {
  // @@protoc_insertion_point(field_get:ReqServiceFaultList.serviceId)
  return _internal_serviceid();
}
inline void ReqServiceFaultList::_internal_set_serviceid(int32_t value) {
  
  serviceid_ = value;
}
inline void ReqServiceFaultList::set_serviceid(int32_t value) {
  _internal_set_serviceid(value);
  // @@protoc_insertion_point(field_set:ReqServiceFaultList.serviceId)
}

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

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

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

// RetServiceFaultElement

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

// string name = 2;
inline void RetServiceFaultElement::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& RetServiceFaultElement::name() const {
  // @@protoc_insertion_point(field_get:RetServiceFaultElement.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetServiceFaultElement::set_name(ArgT0&& arg0, ArgT... args) {
 
 name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetServiceFaultElement.name)
}
inline std::string* RetServiceFaultElement::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:RetServiceFaultElement.name)
  return _s;
}
inline const std::string& RetServiceFaultElement::_internal_name() const {
  return name_.Get();
}
inline void RetServiceFaultElement::_internal_set_name(const std::string& value) {
  
  name_.Set(value, GetArenaForAllocation());
}
inline std::string* RetServiceFaultElement::_internal_mutable_name() {
  
  return name_.Mutable(GetArenaForAllocation());
}
inline std::string* RetServiceFaultElement::release_name() {
  // @@protoc_insertion_point(field_release:RetServiceFaultElement.name)
  return name_.Release();
}
inline void RetServiceFaultElement::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:RetServiceFaultElement.name)
}

// int32 grade = 3;
inline void RetServiceFaultElement::clear_grade() {
  grade_ = 0;
}
inline int32_t RetServiceFaultElement::_internal_grade() const {
  return grade_;
}
inline int32_t RetServiceFaultElement::grade() const {
  // @@protoc_insertion_point(field_get:RetServiceFaultElement.grade)
  return _internal_grade();
}
inline void RetServiceFaultElement::_internal_set_grade(int32_t value) {
  
  grade_ = value;
}
inline void RetServiceFaultElement::set_grade(int32_t value) {
  _internal_set_grade(value);
  // @@protoc_insertion_point(field_set:RetServiceFaultElement.grade)
}

// string code = 4;
inline void RetServiceFaultElement::clear_code() {
  code_.ClearToEmpty();
}
inline const std::string& RetServiceFaultElement::code() const {
  // @@protoc_insertion_point(field_get:RetServiceFaultElement.code)
  return _internal_code();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetServiceFaultElement::set_code(ArgT0&& arg0, ArgT... args) {
 
 code_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetServiceFaultElement.code)
}
inline std::string* RetServiceFaultElement::mutable_code() {
  std::string* _s = _internal_mutable_code();
  // @@protoc_insertion_point(field_mutable:RetServiceFaultElement.code)
  return _s;
}
inline const std::string& RetServiceFaultElement::_internal_code() const {
  return code_.Get();
}
inline void RetServiceFaultElement::_internal_set_code(const std::string& value) {
  
  code_.Set(value, GetArenaForAllocation());
}
inline std::string* RetServiceFaultElement::_internal_mutable_code() {
  
  return code_.Mutable(GetArenaForAllocation());
}
inline std::string* RetServiceFaultElement::release_code() {
  // @@protoc_insertion_point(field_release:RetServiceFaultElement.code)
  return code_.Release();
}
inline void RetServiceFaultElement::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:RetServiceFaultElement.code)
}

// string msg = 5;
inline void RetServiceFaultElement::clear_msg() {
  msg_.ClearToEmpty();
}
inline const std::string& RetServiceFaultElement::msg() const {
  // @@protoc_insertion_point(field_get:RetServiceFaultElement.msg)
  return _internal_msg();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetServiceFaultElement::set_msg(ArgT0&& arg0, ArgT... args) {
 
 msg_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetServiceFaultElement.msg)
}
inline std::string* RetServiceFaultElement::mutable_msg() {
  std::string* _s = _internal_mutable_msg();
  // @@protoc_insertion_point(field_mutable:RetServiceFaultElement.msg)
  return _s;
}
inline const std::string& RetServiceFaultElement::_internal_msg() const {
  return msg_.Get();
}
inline void RetServiceFaultElement::_internal_set_msg(const std::string& value) {
  
  msg_.Set(value, GetArenaForAllocation());
}
inline std::string* RetServiceFaultElement::_internal_mutable_msg() {
  
  return msg_.Mutable(GetArenaForAllocation());
}
inline std::string* RetServiceFaultElement::release_msg() {
  // @@protoc_insertion_point(field_release:RetServiceFaultElement.msg)
  return msg_.Release();
}
inline void RetServiceFaultElement::set_allocated_msg(std::string* msg) {
  if (msg != nullptr) {
    
  } else {
    
  }
  msg_.SetAllocated(msg, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (msg_.IsDefault()) {
    msg_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetServiceFaultElement.msg)
}

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

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

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

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


// @@protoc_insertion_point(namespace_scope)


// @@protoc_insertion_point(global_scope)

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