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

#ifndef GOOGLE_PROTOBUF_INCLUDED_mod_2dsystem_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_mod_2dsystem_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_2dsystem_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_mod_2dsystem_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_mod_2dsystem_2eproto;
class ReqSystemLog;
struct ReqSystemLogDefaultTypeInternal;
extern ReqSystemLogDefaultTypeInternal _ReqSystemLog_default_instance_;
class ReqSystemParam;
struct ReqSystemParamDefaultTypeInternal;
extern ReqSystemParamDefaultTypeInternal _ReqSystemParam_default_instance_;
class RetSystemLogElement;
struct RetSystemLogElementDefaultTypeInternal;
extern RetSystemLogElementDefaultTypeInternal _RetSystemLogElement_default_instance_;
class RetSystemParam;
struct RetSystemParamDefaultTypeInternal;
extern RetSystemParamDefaultTypeInternal _RetSystemParam_default_instance_;
PROTOBUF_NAMESPACE_OPEN
template<> ::ReqSystemLog* Arena::CreateMaybeMessage<::ReqSystemLog>(Arena*);
template<> ::ReqSystemParam* Arena::CreateMaybeMessage<::ReqSystemParam>(Arena*);
template<> ::RetSystemLogElement* Arena::CreateMaybeMessage<::RetSystemLogElement>(Arena*);
template<> ::RetSystemParam* Arena::CreateMaybeMessage<::RetSystemParam>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

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

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ReqSystemParam";
  }
  protected:
  explicit ReqSystemParam(::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 {
    kDataPathFieldNumber = 6,
    kLeastTimeFieldNumber = 1,
    kSwitchTimeFieldNumber = 2,
    kOpTimeFieldNumber = 3,
    kPriorityFieldNumber = 4,
    kStrategyFieldNumber = 5,
    kUidFieldNumber = 7,
  };
  // string dataPath = 6;
  void clear_datapath();
  const std::string& datapath() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_datapath(ArgT0&& arg0, ArgT... args);
  std::string* mutable_datapath();
  PROTOBUF_NODISCARD std::string* release_datapath();
  void set_allocated_datapath(std::string* datapath);
  private:
  const std::string& _internal_datapath() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_datapath(const std::string& value);
  std::string* _internal_mutable_datapath();
  public:

  // int32 leastTime = 1;
  void clear_leasttime();
  int32_t leasttime() const;
  void set_leasttime(int32_t value);
  private:
  int32_t _internal_leasttime() const;
  void _internal_set_leasttime(int32_t value);
  public:

  // int32 switchTime = 2;
  void clear_switchtime();
  int32_t switchtime() const;
  void set_switchtime(int32_t value);
  private:
  int32_t _internal_switchtime() const;
  void _internal_set_switchtime(int32_t value);
  public:

  // int32 opTime = 3;
  void clear_optime();
  int32_t optime() const;
  void set_optime(int32_t value);
  private:
  int32_t _internal_optime() const;
  void _internal_set_optime(int32_t value);
  public:

  // bool priority = 4;
  void clear_priority();
  bool priority() const;
  void set_priority(bool value);
  private:
  bool _internal_priority() const;
  void _internal_set_priority(bool value);
  public:

  // int32 strategy = 5;
  void clear_strategy();
  int32_t strategy() const;
  void set_strategy(int32_t value);
  private:
  int32_t _internal_strategy() const;
  void _internal_set_strategy(int32_t value);
  public:

  // int32 uid = 7;
  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:ReqSystemParam)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr datapath_;
  int32_t leasttime_;
  int32_t switchtime_;
  int32_t optime_;
  bool priority_;
  int32_t strategy_;
  int32_t uid_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2dsystem_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "RetSystemParam";
  }
  protected:
  explicit RetSystemParam(::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 {
    kDataPathFieldNumber = 6,
    kLeastTimeFieldNumber = 1,
    kSwitchTimeFieldNumber = 2,
    kOpTimeFieldNumber = 3,
    kPriorityFieldNumber = 4,
    kStrategyFieldNumber = 5,
  };
  // string dataPath = 6;
  void clear_datapath();
  const std::string& datapath() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_datapath(ArgT0&& arg0, ArgT... args);
  std::string* mutable_datapath();
  PROTOBUF_NODISCARD std::string* release_datapath();
  void set_allocated_datapath(std::string* datapath);
  private:
  const std::string& _internal_datapath() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_datapath(const std::string& value);
  std::string* _internal_mutable_datapath();
  public:

  // int32 leastTime = 1;
  void clear_leasttime();
  int32_t leasttime() const;
  void set_leasttime(int32_t value);
  private:
  int32_t _internal_leasttime() const;
  void _internal_set_leasttime(int32_t value);
  public:

  // int32 switchTime = 2;
  void clear_switchtime();
  int32_t switchtime() const;
  void set_switchtime(int32_t value);
  private:
  int32_t _internal_switchtime() const;
  void _internal_set_switchtime(int32_t value);
  public:

  // int32 opTime = 3;
  void clear_optime();
  int32_t optime() const;
  void set_optime(int32_t value);
  private:
  int32_t _internal_optime() const;
  void _internal_set_optime(int32_t value);
  public:

  // bool priority = 4;
  void clear_priority();
  bool priority() const;
  void set_priority(bool value);
  private:
  bool _internal_priority() const;
  void _internal_set_priority(bool value);
  public:

  // int32 strategy = 5;
  void clear_strategy();
  int32_t strategy() const;
  void set_strategy(int32_t value);
  private:
  int32_t _internal_strategy() const;
  void _internal_set_strategy(int32_t value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr datapath_;
  int32_t leasttime_;
  int32_t switchtime_;
  int32_t optime_;
  bool priority_;
  int32_t strategy_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2dsystem_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ReqSystemLog";
  }
  protected:
  explicit ReqSystemLog(::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 {
    kCategoryFieldNumber = 3,
    kStartDtFieldNumber = 1,
    kEndDtFieldNumber = 2,
    kTypeFieldNumber = 4,
  };
  // repeated string category = 3;
  int category_size() const;
  private:
  int _internal_category_size() const;
  public:
  void clear_category();
  const std::string& category(int index) const;
  std::string* mutable_category(int index);
  void set_category(int index, const std::string& value);
  void set_category(int index, std::string&& value);
  void set_category(int index, const char* value);
  void set_category(int index, const char* value, size_t size);
  std::string* add_category();
  void add_category(const std::string& value);
  void add_category(std::string&& value);
  void add_category(const char* value);
  void add_category(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& category() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_category();
  private:
  const std::string& _internal_category(int index) const;
  std::string* _internal_add_category();
  public:

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

  // string type = 4;
  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:

  // @@protoc_insertion_point(class_scope:ReqSystemLog)
 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> category_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr startdt_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr enddt_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2dsystem_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "RetSystemLogElement";
  }
  protected:
  explicit RetSystemLogElement(::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 {
    kOperatorFieldNumber = 2,
    kCategoryFieldNumber = 3,
    kContentFieldNumber = 4,
    kCreateDtFieldNumber = 5,
    kIdFieldNumber = 1,
  };
  // string operator = 2;
  void clear_operator_();
  const std::string& operator_() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_operator_(ArgT0&& arg0, ArgT... args);
  std::string* mutable_operator_();
  PROTOBUF_NODISCARD std::string* release_operator_();
  void set_allocated_operator_(std::string* operator_);
  private:
  const std::string& _internal_operator_() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_operator_(const std::string& value);
  std::string* _internal_mutable_operator_();
  public:

  // string category = 3;
  void clear_category();
  const std::string& category() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_category(ArgT0&& arg0, ArgT... args);
  std::string* mutable_category();
  PROTOBUF_NODISCARD std::string* release_category();
  void set_allocated_category(std::string* category);
  private:
  const std::string& _internal_category() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_category(const std::string& value);
  std::string* _internal_mutable_category();
  public:

  // string content = 4;
  void clear_content();
  const std::string& content() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_content(ArgT0&& arg0, ArgT... args);
  std::string* mutable_content();
  PROTOBUF_NODISCARD std::string* release_content();
  void set_allocated_content(std::string* content);
  private:
  const std::string& _internal_content() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_content(const std::string& value);
  std::string* _internal_mutable_content();
  public:

  // string createDt = 5;
  void clear_createdt();
  const std::string& createdt() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_createdt(ArgT0&& arg0, ArgT... args);
  std::string* mutable_createdt();
  PROTOBUF_NODISCARD std::string* release_createdt();
  void set_allocated_createdt(std::string* createdt);
  private:
  const std::string& _internal_createdt() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_createdt(const std::string& value);
  std::string* _internal_mutable_createdt();
  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:RetSystemLogElement)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr operator__;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr category_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr createdt_;
  int32_t id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_mod_2dsystem_2eproto;
};
// ===================================================================


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

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

// int32 leastTime = 1;
inline void ReqSystemParam::clear_leasttime() {
  leasttime_ = 0;
}
inline int32_t ReqSystemParam::_internal_leasttime() const {
  return leasttime_;
}
inline int32_t ReqSystemParam::leasttime() const {
  // @@protoc_insertion_point(field_get:ReqSystemParam.leastTime)
  return _internal_leasttime();
}
inline void ReqSystemParam::_internal_set_leasttime(int32_t value) {
  
  leasttime_ = value;
}
inline void ReqSystemParam::set_leasttime(int32_t value) {
  _internal_set_leasttime(value);
  // @@protoc_insertion_point(field_set:ReqSystemParam.leastTime)
}

// int32 switchTime = 2;
inline void ReqSystemParam::clear_switchtime() {
  switchtime_ = 0;
}
inline int32_t ReqSystemParam::_internal_switchtime() const {
  return switchtime_;
}
inline int32_t ReqSystemParam::switchtime() const {
  // @@protoc_insertion_point(field_get:ReqSystemParam.switchTime)
  return _internal_switchtime();
}
inline void ReqSystemParam::_internal_set_switchtime(int32_t value) {
  
  switchtime_ = value;
}
inline void ReqSystemParam::set_switchtime(int32_t value) {
  _internal_set_switchtime(value);
  // @@protoc_insertion_point(field_set:ReqSystemParam.switchTime)
}

// int32 opTime = 3;
inline void ReqSystemParam::clear_optime() {
  optime_ = 0;
}
inline int32_t ReqSystemParam::_internal_optime() const {
  return optime_;
}
inline int32_t ReqSystemParam::optime() const {
  // @@protoc_insertion_point(field_get:ReqSystemParam.opTime)
  return _internal_optime();
}
inline void ReqSystemParam::_internal_set_optime(int32_t value) {
  
  optime_ = value;
}
inline void ReqSystemParam::set_optime(int32_t value) {
  _internal_set_optime(value);
  // @@protoc_insertion_point(field_set:ReqSystemParam.opTime)
}

// bool priority = 4;
inline void ReqSystemParam::clear_priority() {
  priority_ = false;
}
inline bool ReqSystemParam::_internal_priority() const {
  return priority_;
}
inline bool ReqSystemParam::priority() const {
  // @@protoc_insertion_point(field_get:ReqSystemParam.priority)
  return _internal_priority();
}
inline void ReqSystemParam::_internal_set_priority(bool value) {
  
  priority_ = value;
}
inline void ReqSystemParam::set_priority(bool value) {
  _internal_set_priority(value);
  // @@protoc_insertion_point(field_set:ReqSystemParam.priority)
}

// int32 strategy = 5;
inline void ReqSystemParam::clear_strategy() {
  strategy_ = 0;
}
inline int32_t ReqSystemParam::_internal_strategy() const {
  return strategy_;
}
inline int32_t ReqSystemParam::strategy() const {
  // @@protoc_insertion_point(field_get:ReqSystemParam.strategy)
  return _internal_strategy();
}
inline void ReqSystemParam::_internal_set_strategy(int32_t value) {
  
  strategy_ = value;
}
inline void ReqSystemParam::set_strategy(int32_t value) {
  _internal_set_strategy(value);
  // @@protoc_insertion_point(field_set:ReqSystemParam.strategy)
}

// string dataPath = 6;
inline void ReqSystemParam::clear_datapath() {
  datapath_.ClearToEmpty();
}
inline const std::string& ReqSystemParam::datapath() const {
  // @@protoc_insertion_point(field_get:ReqSystemParam.dataPath)
  return _internal_datapath();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqSystemParam::set_datapath(ArgT0&& arg0, ArgT... args) {
 
 datapath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqSystemParam.dataPath)
}
inline std::string* ReqSystemParam::mutable_datapath() {
  std::string* _s = _internal_mutable_datapath();
  // @@protoc_insertion_point(field_mutable:ReqSystemParam.dataPath)
  return _s;
}
inline const std::string& ReqSystemParam::_internal_datapath() const {
  return datapath_.Get();
}
inline void ReqSystemParam::_internal_set_datapath(const std::string& value) {
  
  datapath_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqSystemParam::_internal_mutable_datapath() {
  
  return datapath_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqSystemParam::release_datapath() {
  // @@protoc_insertion_point(field_release:ReqSystemParam.dataPath)
  return datapath_.Release();
}
inline void ReqSystemParam::set_allocated_datapath(std::string* datapath) {
  if (datapath != nullptr) {
    
  } else {
    
  }
  datapath_.SetAllocated(datapath, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (datapath_.IsDefault()) {
    datapath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:ReqSystemParam.dataPath)
}

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

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

// RetSystemParam

// int32 leastTime = 1;
inline void RetSystemParam::clear_leasttime() {
  leasttime_ = 0;
}
inline int32_t RetSystemParam::_internal_leasttime() const {
  return leasttime_;
}
inline int32_t RetSystemParam::leasttime() const {
  // @@protoc_insertion_point(field_get:RetSystemParam.leastTime)
  return _internal_leasttime();
}
inline void RetSystemParam::_internal_set_leasttime(int32_t value) {
  
  leasttime_ = value;
}
inline void RetSystemParam::set_leasttime(int32_t value) {
  _internal_set_leasttime(value);
  // @@protoc_insertion_point(field_set:RetSystemParam.leastTime)
}

// int32 switchTime = 2;
inline void RetSystemParam::clear_switchtime() {
  switchtime_ = 0;
}
inline int32_t RetSystemParam::_internal_switchtime() const {
  return switchtime_;
}
inline int32_t RetSystemParam::switchtime() const {
  // @@protoc_insertion_point(field_get:RetSystemParam.switchTime)
  return _internal_switchtime();
}
inline void RetSystemParam::_internal_set_switchtime(int32_t value) {
  
  switchtime_ = value;
}
inline void RetSystemParam::set_switchtime(int32_t value) {
  _internal_set_switchtime(value);
  // @@protoc_insertion_point(field_set:RetSystemParam.switchTime)
}

// int32 opTime = 3;
inline void RetSystemParam::clear_optime() {
  optime_ = 0;
}
inline int32_t RetSystemParam::_internal_optime() const {
  return optime_;
}
inline int32_t RetSystemParam::optime() const {
  // @@protoc_insertion_point(field_get:RetSystemParam.opTime)
  return _internal_optime();
}
inline void RetSystemParam::_internal_set_optime(int32_t value) {
  
  optime_ = value;
}
inline void RetSystemParam::set_optime(int32_t value) {
  _internal_set_optime(value);
  // @@protoc_insertion_point(field_set:RetSystemParam.opTime)
}

// bool priority = 4;
inline void RetSystemParam::clear_priority() {
  priority_ = false;
}
inline bool RetSystemParam::_internal_priority() const {
  return priority_;
}
inline bool RetSystemParam::priority() const {
  // @@protoc_insertion_point(field_get:RetSystemParam.priority)
  return _internal_priority();
}
inline void RetSystemParam::_internal_set_priority(bool value) {
  
  priority_ = value;
}
inline void RetSystemParam::set_priority(bool value) {
  _internal_set_priority(value);
  // @@protoc_insertion_point(field_set:RetSystemParam.priority)
}

// int32 strategy = 5;
inline void RetSystemParam::clear_strategy() {
  strategy_ = 0;
}
inline int32_t RetSystemParam::_internal_strategy() const {
  return strategy_;
}
inline int32_t RetSystemParam::strategy() const {
  // @@protoc_insertion_point(field_get:RetSystemParam.strategy)
  return _internal_strategy();
}
inline void RetSystemParam::_internal_set_strategy(int32_t value) {
  
  strategy_ = value;
}
inline void RetSystemParam::set_strategy(int32_t value) {
  _internal_set_strategy(value);
  // @@protoc_insertion_point(field_set:RetSystemParam.strategy)
}

// string dataPath = 6;
inline void RetSystemParam::clear_datapath() {
  datapath_.ClearToEmpty();
}
inline const std::string& RetSystemParam::datapath() const {
  // @@protoc_insertion_point(field_get:RetSystemParam.dataPath)
  return _internal_datapath();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSystemParam::set_datapath(ArgT0&& arg0, ArgT... args) {
 
 datapath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSystemParam.dataPath)
}
inline std::string* RetSystemParam::mutable_datapath() {
  std::string* _s = _internal_mutable_datapath();
  // @@protoc_insertion_point(field_mutable:RetSystemParam.dataPath)
  return _s;
}
inline const std::string& RetSystemParam::_internal_datapath() const {
  return datapath_.Get();
}
inline void RetSystemParam::_internal_set_datapath(const std::string& value) {
  
  datapath_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSystemParam::_internal_mutable_datapath() {
  
  return datapath_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSystemParam::release_datapath() {
  // @@protoc_insertion_point(field_release:RetSystemParam.dataPath)
  return datapath_.Release();
}
inline void RetSystemParam::set_allocated_datapath(std::string* datapath) {
  if (datapath != nullptr) {
    
  } else {
    
  }
  datapath_.SetAllocated(datapath, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (datapath_.IsDefault()) {
    datapath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSystemParam.dataPath)
}

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

// ReqSystemLog

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

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

// repeated string category = 3;
inline int ReqSystemLog::_internal_category_size() const {
  return category_.size();
}
inline int ReqSystemLog::category_size() const {
  return _internal_category_size();
}
inline void ReqSystemLog::clear_category() {
  category_.Clear();
}
inline std::string* ReqSystemLog::add_category() {
  std::string* _s = _internal_add_category();
  // @@protoc_insertion_point(field_add_mutable:ReqSystemLog.category)
  return _s;
}
inline const std::string& ReqSystemLog::_internal_category(int index) const {
  return category_.Get(index);
}
inline const std::string& ReqSystemLog::category(int index) const {
  // @@protoc_insertion_point(field_get:ReqSystemLog.category)
  return _internal_category(index);
}
inline std::string* ReqSystemLog::mutable_category(int index) {
  // @@protoc_insertion_point(field_mutable:ReqSystemLog.category)
  return category_.Mutable(index);
}
inline void ReqSystemLog::set_category(int index, const std::string& value) {
  category_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:ReqSystemLog.category)
}
inline void ReqSystemLog::set_category(int index, std::string&& value) {
  category_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:ReqSystemLog.category)
}
inline void ReqSystemLog::set_category(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  category_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:ReqSystemLog.category)
}
inline void ReqSystemLog::set_category(int index, const char* value, size_t size) {
  category_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:ReqSystemLog.category)
}
inline std::string* ReqSystemLog::_internal_add_category() {
  return category_.Add();
}
inline void ReqSystemLog::add_category(const std::string& value) {
  category_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:ReqSystemLog.category)
}
inline void ReqSystemLog::add_category(std::string&& value) {
  category_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:ReqSystemLog.category)
}
inline void ReqSystemLog::add_category(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  category_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:ReqSystemLog.category)
}
inline void ReqSystemLog::add_category(const char* value, size_t size) {
  category_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:ReqSystemLog.category)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
ReqSystemLog::category() const {
  // @@protoc_insertion_point(field_list:ReqSystemLog.category)
  return category_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
ReqSystemLog::mutable_category() {
  // @@protoc_insertion_point(field_mutable_list:ReqSystemLog.category)
  return &category_;
}

// string type = 4;
inline void ReqSystemLog::clear_type() {
  type_.ClearToEmpty();
}
inline const std::string& ReqSystemLog::type() const {
  // @@protoc_insertion_point(field_get:ReqSystemLog.type)
  return _internal_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ReqSystemLog::set_type(ArgT0&& arg0, ArgT... args) {
 
 type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:ReqSystemLog.type)
}
inline std::string* ReqSystemLog::mutable_type() {
  std::string* _s = _internal_mutable_type();
  // @@protoc_insertion_point(field_mutable:ReqSystemLog.type)
  return _s;
}
inline const std::string& ReqSystemLog::_internal_type() const {
  return type_.Get();
}
inline void ReqSystemLog::_internal_set_type(const std::string& value) {
  
  type_.Set(value, GetArenaForAllocation());
}
inline std::string* ReqSystemLog::_internal_mutable_type() {
  
  return type_.Mutable(GetArenaForAllocation());
}
inline std::string* ReqSystemLog::release_type() {
  // @@protoc_insertion_point(field_release:ReqSystemLog.type)
  return type_.Release();
}
inline void ReqSystemLog::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:ReqSystemLog.type)
}

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

// RetSystemLogElement

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

// string operator = 2;
inline void RetSystemLogElement::clear_operator_() {
  operator__.ClearToEmpty();
}
inline const std::string& RetSystemLogElement::operator_() const {
  // @@protoc_insertion_point(field_get:RetSystemLogElement.operator)
  return _internal_operator_();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSystemLogElement::set_operator_(ArgT0&& arg0, ArgT... args) {
 
 operator__.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSystemLogElement.operator)
}
inline std::string* RetSystemLogElement::mutable_operator_() {
  std::string* _s = _internal_mutable_operator_();
  // @@protoc_insertion_point(field_mutable:RetSystemLogElement.operator)
  return _s;
}
inline const std::string& RetSystemLogElement::_internal_operator_() const {
  return operator__.Get();
}
inline void RetSystemLogElement::_internal_set_operator_(const std::string& value) {
  
  operator__.Set(value, GetArenaForAllocation());
}
inline std::string* RetSystemLogElement::_internal_mutable_operator_() {
  
  return operator__.Mutable(GetArenaForAllocation());
}
inline std::string* RetSystemLogElement::release_operator_() {
  // @@protoc_insertion_point(field_release:RetSystemLogElement.operator)
  return operator__.Release();
}
inline void RetSystemLogElement::set_allocated_operator_(std::string* operator_) {
  if (operator_ != nullptr) {
    
  } else {
    
  }
  operator__.SetAllocated(operator_, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (operator__.IsDefault()) {
    operator__.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSystemLogElement.operator)
}

// string category = 3;
inline void RetSystemLogElement::clear_category() {
  category_.ClearToEmpty();
}
inline const std::string& RetSystemLogElement::category() const {
  // @@protoc_insertion_point(field_get:RetSystemLogElement.category)
  return _internal_category();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSystemLogElement::set_category(ArgT0&& arg0, ArgT... args) {
 
 category_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSystemLogElement.category)
}
inline std::string* RetSystemLogElement::mutable_category() {
  std::string* _s = _internal_mutable_category();
  // @@protoc_insertion_point(field_mutable:RetSystemLogElement.category)
  return _s;
}
inline const std::string& RetSystemLogElement::_internal_category() const {
  return category_.Get();
}
inline void RetSystemLogElement::_internal_set_category(const std::string& value) {
  
  category_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSystemLogElement::_internal_mutable_category() {
  
  return category_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSystemLogElement::release_category() {
  // @@protoc_insertion_point(field_release:RetSystemLogElement.category)
  return category_.Release();
}
inline void RetSystemLogElement::set_allocated_category(std::string* category) {
  if (category != nullptr) {
    
  } else {
    
  }
  category_.SetAllocated(category, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (category_.IsDefault()) {
    category_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSystemLogElement.category)
}

// string content = 4;
inline void RetSystemLogElement::clear_content() {
  content_.ClearToEmpty();
}
inline const std::string& RetSystemLogElement::content() const {
  // @@protoc_insertion_point(field_get:RetSystemLogElement.content)
  return _internal_content();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSystemLogElement::set_content(ArgT0&& arg0, ArgT... args) {
 
 content_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSystemLogElement.content)
}
inline std::string* RetSystemLogElement::mutable_content() {
  std::string* _s = _internal_mutable_content();
  // @@protoc_insertion_point(field_mutable:RetSystemLogElement.content)
  return _s;
}
inline const std::string& RetSystemLogElement::_internal_content() const {
  return content_.Get();
}
inline void RetSystemLogElement::_internal_set_content(const std::string& value) {
  
  content_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSystemLogElement::_internal_mutable_content() {
  
  return content_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSystemLogElement::release_content() {
  // @@protoc_insertion_point(field_release:RetSystemLogElement.content)
  return content_.Release();
}
inline void RetSystemLogElement::set_allocated_content(std::string* content) {
  if (content != nullptr) {
    
  } else {
    
  }
  content_.SetAllocated(content, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (content_.IsDefault()) {
    content_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSystemLogElement.content)
}

// string createDt = 5;
inline void RetSystemLogElement::clear_createdt() {
  createdt_.ClearToEmpty();
}
inline const std::string& RetSystemLogElement::createdt() const {
  // @@protoc_insertion_point(field_get:RetSystemLogElement.createDt)
  return _internal_createdt();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RetSystemLogElement::set_createdt(ArgT0&& arg0, ArgT... args) {
 
 createdt_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:RetSystemLogElement.createDt)
}
inline std::string* RetSystemLogElement::mutable_createdt() {
  std::string* _s = _internal_mutable_createdt();
  // @@protoc_insertion_point(field_mutable:RetSystemLogElement.createDt)
  return _s;
}
inline const std::string& RetSystemLogElement::_internal_createdt() const {
  return createdt_.Get();
}
inline void RetSystemLogElement::_internal_set_createdt(const std::string& value) {
  
  createdt_.Set(value, GetArenaForAllocation());
}
inline std::string* RetSystemLogElement::_internal_mutable_createdt() {
  
  return createdt_.Mutable(GetArenaForAllocation());
}
inline std::string* RetSystemLogElement::release_createdt() {
  // @@protoc_insertion_point(field_release:RetSystemLogElement.createDt)
  return createdt_.Release();
}
inline void RetSystemLogElement::set_allocated_createdt(std::string* createdt) {
  if (createdt != nullptr) {
    
  } else {
    
  }
  createdt_.SetAllocated(createdt, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (createdt_.IsDefault()) {
    createdt_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:RetSystemLogElement.createDt)
}

#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_2dsystem_2eproto
