// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: OAM_datastruct.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_OAM_5fdatastruct_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_OAM_5fdatastruct_2eproto

#include <limits>
#include <string>

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

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

// Internal implementation detail -- do not use these members.
struct TableStruct_OAM_5fdatastruct_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_OAM_5fdatastruct_2eproto;
class AlarmAttri;
struct AlarmAttriDefaultTypeInternal;
extern AlarmAttriDefaultTypeInternal _AlarmAttri_default_instance_;
class CurrAlarm;
struct CurrAlarmDefaultTypeInternal;
extern CurrAlarmDefaultTypeInternal _CurrAlarm_default_instance_;
class DeviceRet;
struct DeviceRetDefaultTypeInternal;
extern DeviceRetDefaultTypeInternal _DeviceRet_default_instance_;
class HisAlarm;
struct HisAlarmDefaultTypeInternal;
extern HisAlarmDefaultTypeInternal _HisAlarm_default_instance_;
class Log;
struct LogDefaultTypeInternal;
extern LogDefaultTypeInternal _Log_default_instance_;
class PerAttri;
struct PerAttriDefaultTypeInternal;
extern PerAttriDefaultTypeInternal _PerAttri_default_instance_;
class PerInfo;
struct PerInfoDefaultTypeInternal;
extern PerInfoDefaultTypeInternal _PerInfo_default_instance_;
class PerRequire;
struct PerRequireDefaultTypeInternal;
extern PerRequireDefaultTypeInternal _PerRequire_default_instance_;
class Respond;
struct RespondDefaultTypeInternal;
extern RespondDefaultTypeInternal _Respond_default_instance_;
class StationDevID;
struct StationDevIDDefaultTypeInternal;
extern StationDevIDDefaultTypeInternal _StationDevID_default_instance_;
class SysStatus;
struct SysStatusDefaultTypeInternal;
extern SysStatusDefaultTypeInternal _SysStatus_default_instance_;
PROTOBUF_NAMESPACE_OPEN
template<> ::AlarmAttri* Arena::CreateMaybeMessage<::AlarmAttri>(Arena*);
template<> ::CurrAlarm* Arena::CreateMaybeMessage<::CurrAlarm>(Arena*);
template<> ::DeviceRet* Arena::CreateMaybeMessage<::DeviceRet>(Arena*);
template<> ::HisAlarm* Arena::CreateMaybeMessage<::HisAlarm>(Arena*);
template<> ::Log* Arena::CreateMaybeMessage<::Log>(Arena*);
template<> ::PerAttri* Arena::CreateMaybeMessage<::PerAttri>(Arena*);
template<> ::PerInfo* Arena::CreateMaybeMessage<::PerInfo>(Arena*);
template<> ::PerRequire* Arena::CreateMaybeMessage<::PerRequire>(Arena*);
template<> ::Respond* Arena::CreateMaybeMessage<::Respond>(Arena*);
template<> ::StationDevID* Arena::CreateMaybeMessage<::StationDevID>(Arena*);
template<> ::SysStatus* Arena::CreateMaybeMessage<::SysStatus>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

enum Level : int {
  Defaul_Level = 0,
  Normal_Alarm = 1,
  Critical_Alarm = 2,
  Level_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  Level_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool Level_IsValid(int value);
constexpr Level Level_MIN = Defaul_Level;
constexpr Level Level_MAX = Critical_Alarm;
constexpr int Level_ARRAYSIZE = Level_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Level_descriptor();
template<typename T>
inline const std::string& Level_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Level>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Level_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Level_descriptor(), enum_t_value);
}
inline bool Level_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Level* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Level>(
    Level_descriptor(), name, value);
}
enum LogLevel : int {
  Default_LogLevel = 0,
  Normal = 1,
  Warning = 2,
  Error = 3,
  LogLevel_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  LogLevel_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool LogLevel_IsValid(int value);
constexpr LogLevel LogLevel_MIN = Default_LogLevel;
constexpr LogLevel LogLevel_MAX = Error;
constexpr int LogLevel_ARRAYSIZE = LogLevel_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LogLevel_descriptor();
template<typename T>
inline const std::string& LogLevel_Name(T enum_t_value) {
  static_assert(::std::is_same<T, LogLevel>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function LogLevel_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    LogLevel_descriptor(), enum_t_value);
}
inline bool LogLevel_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LogLevel* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LogLevel>(
    LogLevel_descriptor(), name, value);
}
enum OperandType : int {
  _DEFAULT = 0,
  _UINT = 1,
  _INT = 2,
  _STRING = 3,
  _FLOAT = 4,
  _DOUBLE = 5,
  OperandType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  OperandType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool OperandType_IsValid(int value);
constexpr OperandType OperandType_MIN = _DEFAULT;
constexpr OperandType OperandType_MAX = _DOUBLE;
constexpr int OperandType_ARRAYSIZE = OperandType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* OperandType_descriptor();
template<typename T>
inline const std::string& OperandType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, OperandType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function OperandType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    OperandType_descriptor(), enum_t_value);
}
inline bool OperandType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OperandType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<OperandType>(
    OperandType_descriptor(), name, value);
}
enum Operator : int {
  Default_Operator = 0,
  GreaterThan = 1,
  GreaterThanOrEqualTo = 2,
  EqualTo = 3,
  LessThan = 4,
  LessThanOrEqualTo = 5,
  NotEqualTo = 6,
  Operator_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  Operator_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool Operator_IsValid(int value);
constexpr Operator Operator_MIN = Default_Operator;
constexpr Operator Operator_MAX = NotEqualTo;
constexpr int Operator_ARRAYSIZE = Operator_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Operator_descriptor();
template<typename T>
inline const std::string& Operator_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Operator>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Operator_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Operator_descriptor(), enum_t_value);
}
inline bool Operator_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Operator* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Operator>(
    Operator_descriptor(), name, value);
}
enum RelationOperator : int {
  Default_RelationOperator = 0,
  AND = 1,
  OR = 2,
  RelationOperator_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  RelationOperator_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool RelationOperator_IsValid(int value);
constexpr RelationOperator RelationOperator_MIN = Default_RelationOperator;
constexpr RelationOperator RelationOperator_MAX = OR;
constexpr int RelationOperator_ARRAYSIZE = RelationOperator_MAX + 1;

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

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "DeviceRet";
  }
  protected:
  explicit DeviceRet(::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 {
    kMessageFieldNumber = 5,
    kAlarmIDFieldNumber = 1,
    kStationIDFieldNumber = 2,
    kDeviceIDFieldNumber = 3,
    kCodeRetFieldNumber = 4,
  };
  // string Message = 5;
  void clear_message();
  const std::string& message() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_message(ArgT0&& arg0, ArgT... args);
  std::string* mutable_message();
  PROTOBUF_NODISCARD std::string* release_message();
  void set_allocated_message(std::string* message);
  private:
  const std::string& _internal_message() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_message(const std::string& value);
  std::string* _internal_mutable_message();
  public:

  // uint32 AlarmID = 1;
  void clear_alarmid();
  uint32_t alarmid() const;
  void set_alarmid(uint32_t value);
  private:
  uint32_t _internal_alarmid() const;
  void _internal_set_alarmid(uint32_t value);
  public:

  // uint32 StationID = 2;
  void clear_stationid();
  uint32_t stationid() const;
  void set_stationid(uint32_t value);
  private:
  uint32_t _internal_stationid() const;
  void _internal_set_stationid(uint32_t value);
  public:

  // uint32 DeviceID = 3;
  void clear_deviceid();
  uint32_t deviceid() const;
  void set_deviceid(uint32_t value);
  private:
  uint32_t _internal_deviceid() const;
  void _internal_set_deviceid(uint32_t value);
  public:

  // .CodeValue CodeRet = 4;
  void clear_coderet();
  ::CodeValue coderet() const;
  void set_coderet(::CodeValue value);
  private:
  ::CodeValue _internal_coderet() const;
  void _internal_set_coderet(::CodeValue value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_;
  uint32_t alarmid_;
  uint32_t stationid_;
  uint32_t deviceid_;
  int coderet_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_OAM_5fdatastruct_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Respond";
  }
  protected:
  explicit Respond(::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 {
    kMessageFieldNumber = 2,
    kCodeRetFieldNumber = 1,
  };
  // string Message = 2;
  void clear_message();
  const std::string& message() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_message(ArgT0&& arg0, ArgT... args);
  std::string* mutable_message();
  PROTOBUF_NODISCARD std::string* release_message();
  void set_allocated_message(std::string* message);
  private:
  const std::string& _internal_message() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_message(const std::string& value);
  std::string* _internal_mutable_message();
  public:

  // .CodeValue CodeRet = 1;
  void clear_coderet();
  ::CodeValue coderet() const;
  void set_coderet(::CodeValue value);
  private:
  ::CodeValue _internal_coderet() const;
  void _internal_set_coderet(::CodeValue value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_;
  int coderet_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_OAM_5fdatastruct_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "StationDevID";
  }
  protected:
  explicit StationDevID(::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 {
    kStationIDFieldNumber = 1,
    kDeviceIDFieldNumber = 2,
  };
  // uint32 StationID = 1;
  void clear_stationid();
  uint32_t stationid() const;
  void set_stationid(uint32_t value);
  private:
  uint32_t _internal_stationid() const;
  void _internal_set_stationid(uint32_t value);
  public:

  // uint32 DeviceID = 2;
  void clear_deviceid();
  uint32_t deviceid() const;
  void set_deviceid(uint32_t value);
  private:
  uint32_t _internal_deviceid() const;
  void _internal_set_deviceid(uint32_t value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  uint32_t stationid_;
  uint32_t deviceid_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_OAM_5fdatastruct_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "AlarmAttri";
  }
  protected:
  explicit AlarmAttri(::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 {
    kAlarmDescriptionCHNFieldNumber = 4,
    kAlarmDescriptionENGFieldNumber = 5,
    kCreateTimeFieldNumber = 7,
    kIdFieldNumber = 1,
    kAlarmIDFieldNumber = 2,
    kAlarmLevelFieldNumber = 3,
    kIsMonFieldNumber = 6,
  };
  // string AlarmDescriptionCHN = 4;
  void clear_alarmdescriptionchn();
  const std::string& alarmdescriptionchn() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_alarmdescriptionchn(ArgT0&& arg0, ArgT... args);
  std::string* mutable_alarmdescriptionchn();
  PROTOBUF_NODISCARD std::string* release_alarmdescriptionchn();
  void set_allocated_alarmdescriptionchn(std::string* alarmdescriptionchn);
  private:
  const std::string& _internal_alarmdescriptionchn() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_alarmdescriptionchn(const std::string& value);
  std::string* _internal_mutable_alarmdescriptionchn();
  public:

  // string AlarmDescriptionENG = 5;
  void clear_alarmdescriptioneng();
  const std::string& alarmdescriptioneng() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_alarmdescriptioneng(ArgT0&& arg0, ArgT... args);
  std::string* mutable_alarmdescriptioneng();
  PROTOBUF_NODISCARD std::string* release_alarmdescriptioneng();
  void set_allocated_alarmdescriptioneng(std::string* alarmdescriptioneng);
  private:
  const std::string& _internal_alarmdescriptioneng() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_alarmdescriptioneng(const std::string& value);
  std::string* _internal_mutable_alarmdescriptioneng();
  public:

  // .google.protobuf.Timestamp CreateTime = 7;
  bool has_createtime() const;
  private:
  bool _internal_has_createtime() const;
  public:
  void clear_createtime();
  const ::PROTOBUF_NAMESPACE_ID::Timestamp& createtime() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Timestamp* release_createtime();
  ::PROTOBUF_NAMESPACE_ID::Timestamp* mutable_createtime();
  void set_allocated_createtime(::PROTOBUF_NAMESPACE_ID::Timestamp* createtime);
  private:
  const ::PROTOBUF_NAMESPACE_ID::Timestamp& _internal_createtime() const;
  ::PROTOBUF_NAMESPACE_ID::Timestamp* _internal_mutable_createtime();
  public:
  void unsafe_arena_set_allocated_createtime(
      ::PROTOBUF_NAMESPACE_ID::Timestamp* createtime);
  ::PROTOBUF_NAMESPACE_ID::Timestamp* unsafe_arena_release_createtime();

  // uint32 Id = 1;
  void clear_id();
  uint32_t id() const;
  void set_id(uint32_t value);
  private:
  uint32_t _internal_id() const;
  void _internal_set_id(uint32_t value);
  public:

  // uint32 AlarmID = 2;
  void clear_alarmid();
  uint32_t alarmid() const;
  void set_alarmid(uint32_t value);
  private:
  uint32_t _internal_alarmid() const;
  void _internal_set_alarmid(uint32_t value);
  public:

  // .Level AlarmLevel = 3;
  void clear_alarmlevel();
  ::Level alarmlevel() const;
  void set_alarmlevel(::Level value);
  private:
  ::Level _internal_alarmlevel() const;
  void _internal_set_alarmlevel(::Level value);
  public:

  // uint32 IsMon = 6;
  void clear_ismon();
  uint32_t ismon() const;
  void set_ismon(uint32_t value);
  private:
  uint32_t _internal_ismon() const;
  void _internal_set_ismon(uint32_t value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr alarmdescriptionchn_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr alarmdescriptioneng_;
  ::PROTOBUF_NAMESPACE_ID::Timestamp* createtime_;
  uint32_t id_;
  uint32_t alarmid_;
  int alarmlevel_;
  uint32_t ismon_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_OAM_5fdatastruct_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "PerAttri";
  }
  protected:
  explicit PerAttri(::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 {
    kDataCatlogFieldNumber = 3,
    kFieldNameFieldNumber = 4,
    kPerDescriptionCHNFieldNumber = 5,
    kPerDescriptionENGFieldNumber = 6,
    kFieldUnitFieldNumber = 8,
    kOperand1FieldNumber = 10,
    kOperand2FieldNumber = 13,
    kAlarmDesCHNFieldNumber = 16,
    kAlarmDesENGFieldNumber = 17,
    kCreateTimeFieldNumber = 18,
    kIdFieldNumber = 1,
    kPerIDFieldNumber = 2,
    kFieldTypeFieldNumber = 7,
    kOperator1FieldNumber = 9,
    kRelationFieldNumber = 11,
    kOperator2FieldNumber = 12,
    kIsMonFieldNumber = 14,
    kPerAlarmLevelFieldNumber = 15,
  };
  // string DataCatlog = 3;
  void clear_datacatlog();
  const std::string& datacatlog() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_datacatlog(ArgT0&& arg0, ArgT... args);
  std::string* mutable_datacatlog();
  PROTOBUF_NODISCARD std::string* release_datacatlog();
  void set_allocated_datacatlog(std::string* datacatlog);
  private:
  const std::string& _internal_datacatlog() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_datacatlog(const std::string& value);
  std::string* _internal_mutable_datacatlog();
  public:

  // string FieldName = 4;
  void clear_fieldname();
  const std::string& fieldname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fieldname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fieldname();
  PROTOBUF_NODISCARD std::string* release_fieldname();
  void set_allocated_fieldname(std::string* fieldname);
  private:
  const std::string& _internal_fieldname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fieldname(const std::string& value);
  std::string* _internal_mutable_fieldname();
  public:

  // string PerDescriptionCHN = 5;
  void clear_perdescriptionchn();
  const std::string& perdescriptionchn() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_perdescriptionchn(ArgT0&& arg0, ArgT... args);
  std::string* mutable_perdescriptionchn();
  PROTOBUF_NODISCARD std::string* release_perdescriptionchn();
  void set_allocated_perdescriptionchn(std::string* perdescriptionchn);
  private:
  const std::string& _internal_perdescriptionchn() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_perdescriptionchn(const std::string& value);
  std::string* _internal_mutable_perdescriptionchn();
  public:

  // string PerDescriptionENG = 6;
  void clear_perdescriptioneng();
  const std::string& perdescriptioneng() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_perdescriptioneng(ArgT0&& arg0, ArgT... args);
  std::string* mutable_perdescriptioneng();
  PROTOBUF_NODISCARD std::string* release_perdescriptioneng();
  void set_allocated_perdescriptioneng(std::string* perdescriptioneng);
  private:
  const std::string& _internal_perdescriptioneng() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_perdescriptioneng(const std::string& value);
  std::string* _internal_mutable_perdescriptioneng();
  public:

  // string FieldUnit = 8;
  void clear_fieldunit();
  const std::string& fieldunit() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fieldunit(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fieldunit();
  PROTOBUF_NODISCARD std::string* release_fieldunit();
  void set_allocated_fieldunit(std::string* fieldunit);
  private:
  const std::string& _internal_fieldunit() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fieldunit(const std::string& value);
  std::string* _internal_mutable_fieldunit();
  public:

  // string Operand1 = 10;
  void clear_operand1();
  const std::string& operand1() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_operand1(ArgT0&& arg0, ArgT... args);
  std::string* mutable_operand1();
  PROTOBUF_NODISCARD std::string* release_operand1();
  void set_allocated_operand1(std::string* operand1);
  private:
  const std::string& _internal_operand1() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_operand1(const std::string& value);
  std::string* _internal_mutable_operand1();
  public:

  // string Operand2 = 13;
  void clear_operand2();
  const std::string& operand2() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_operand2(ArgT0&& arg0, ArgT... args);
  std::string* mutable_operand2();
  PROTOBUF_NODISCARD std::string* release_operand2();
  void set_allocated_operand2(std::string* operand2);
  private:
  const std::string& _internal_operand2() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_operand2(const std::string& value);
  std::string* _internal_mutable_operand2();
  public:

  // string AlarmDesCHN = 16;
  void clear_alarmdeschn();
  const std::string& alarmdeschn() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_alarmdeschn(ArgT0&& arg0, ArgT... args);
  std::string* mutable_alarmdeschn();
  PROTOBUF_NODISCARD std::string* release_alarmdeschn();
  void set_allocated_alarmdeschn(std::string* alarmdeschn);
  private:
  const std::string& _internal_alarmdeschn() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_alarmdeschn(const std::string& value);
  std::string* _internal_mutable_alarmdeschn();
  public:

  // string AlarmDesENG = 17;
  void clear_alarmdeseng();
  const std::string& alarmdeseng() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_alarmdeseng(ArgT0&& arg0, ArgT... args);
  std::string* mutable_alarmdeseng();
  PROTOBUF_NODISCARD std::string* release_alarmdeseng();
  void set_allocated_alarmdeseng(std::string* alarmdeseng);
  private:
  const std::string& _internal_alarmdeseng() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_alarmdeseng(const std::string& value);
  std::string* _internal_mutable_alarmdeseng();
  public:

  // .google.protobuf.Timestamp CreateTime = 18;
  bool has_createtime() const;
  private:
  bool _internal_has_createtime() const;
  public:
  void clear_createtime();
  const ::PROTOBUF_NAMESPACE_ID::Timestamp& createtime() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Timestamp* release_createtime();
  ::PROTOBUF_NAMESPACE_ID::Timestamp* mutable_createtime();
  void set_allocated_createtime(::PROTOBUF_NAMESPACE_ID::Timestamp* createtime);
  private:
  const ::PROTOBUF_NAMESPACE_ID::Timestamp& _internal_createtime() const;
  ::PROTOBUF_NAMESPACE_ID::Timestamp* _internal_mutable_createtime();
  public:
  void unsafe_arena_set_allocated_createtime(
      ::PROTOBUF_NAMESPACE_ID::Timestamp* createtime);
  ::PROTOBUF_NAMESPACE_ID::Timestamp* unsafe_arena_release_createtime();

  // uint32 Id = 1;
  void clear_id();
  uint32_t id() const;
  void set_id(uint32_t value);
  private:
  uint32_t _internal_id() const;
  void _internal_set_id(uint32_t value);
  public:

  // uint32 PerID = 2;
  void clear_perid();
  uint32_t perid() const;
  void set_perid(uint32_t value);
  private:
  uint32_t _internal_perid() const;
  void _internal_set_perid(uint32_t value);
  public:

  // .OperandType FieldType = 7;
  void clear_fieldtype();
  ::OperandType fieldtype() const;
  void set_fieldtype(::OperandType value);
  private:
  ::OperandType _internal_fieldtype() const;
  void _internal_set_fieldtype(::OperandType value);
  public:

  // .Operator Operator1 = 9;
  void clear_operator1();
  ::Operator operator1() const;
  void set_operator1(::Operator value);
  private:
  ::Operator _internal_operator1() const;
  void _internal_set_operator1(::Operator value);
  public:

  // .RelationOperator Relation = 11;
  void clear_relation();
  ::RelationOperator relation() const;
  void set_relation(::RelationOperator value);
  private:
  ::RelationOperator _internal_relation() const;
  void _internal_set_relation(::RelationOperator value);
  public:

  // .Operator Operator2 = 12;
  void clear_operator2();
  ::Operator operator2() const;
  void set_operator2(::Operator value);
  private:
  ::Operator _internal_operator2() const;
  void _internal_set_operator2(::Operator value);
  public:

  // uint32 IsMon = 14;
  void clear_ismon();
  uint32_t ismon() const;
  void set_ismon(uint32_t value);
  private:
  uint32_t _internal_ismon() const;
  void _internal_set_ismon(uint32_t value);
  public:

  // .Level PerAlarmLevel = 15;
  void clear_peralarmlevel();
  ::Level peralarmlevel() const;
  void set_peralarmlevel(::Level value);
  private:
  ::Level _internal_peralarmlevel() const;
  void _internal_set_peralarmlevel(::Level value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr datacatlog_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fieldname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr perdescriptionchn_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr perdescriptioneng_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fieldunit_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr operand1_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr operand2_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr alarmdeschn_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr alarmdeseng_;
  ::PROTOBUF_NAMESPACE_ID::Timestamp* createtime_;
  uint32_t id_;
  uint32_t perid_;
  int fieldtype_;
  int operator1_;
  int relation_;
  int operator2_;
  uint32_t ismon_;
  int peralarmlevel_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_OAM_5fdatastruct_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CurrAlarm";
  }
  protected:
  explicit CurrAlarm(::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 {
    kAlarmDescriptionCHNFieldNumber = 6,
    kAlarmDescriptionENGFieldNumber = 7,
    kReportTimeFieldNumber = 8,
    kIdFieldNumber = 1,
    kAlarmIDFieldNumber = 2,
    kStationIDFieldNumber = 3,
    kDeviceIDFieldNumber = 4,
    kAlarmLevelFieldNumber = 5,
  };
  // string AlarmDescriptionCHN = 6;
  void clear_alarmdescriptionchn();
  const std::string& alarmdescriptionchn() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_alarmdescriptionchn(ArgT0&& arg0, ArgT... args);
  std::string* mutable_alarmdescriptionchn();
  PROTOBUF_NODISCARD std::string* release_alarmdescriptionchn();
  void set_allocated_alarmdescriptionchn(std::string* alarmdescriptionchn);
  private:
  const std::string& _internal_alarmdescriptionchn() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_alarmdescriptionchn(const std::string& value);
  std::string* _internal_mutable_alarmdescriptionchn();
  public:

  // string AlarmDescriptionENG = 7;
  void clear_alarmdescriptioneng();
  const std::string& alarmdescriptioneng() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_alarmdescriptioneng(ArgT0&& arg0, ArgT... args);
  std::string* mutable_alarmdescriptioneng();
  PROTOBUF_NODISCARD std::string* release_alarmdescriptioneng();
  void set_allocated_alarmdescriptioneng(std::string* alarmdescriptioneng);
  private:
  const std::string& _internal_alarmdescriptioneng() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_alarmdescriptioneng(const std::string& value);
  std::string* _internal_mutable_alarmdescriptioneng();
  public:

  // .google.protobuf.Timestamp ReportTime = 8;
  bool has_reporttime() const;
  private:
  bool _internal_has_reporttime() const;
  public:
  void clear_reporttime();
  const ::PROTOBUF_NAMESPACE_ID::Timestamp& reporttime() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Timestamp* release_reporttime();
  ::PROTOBUF_NAMESPACE_ID::Timestamp* mutable_reporttime();
  void set_allocated_reporttime(::PROTOBUF_NAMESPACE_ID::Timestamp* reporttime);
  private:
  const ::PROTOBUF_NAMESPACE_ID::Timestamp& _internal_reporttime() const;
  ::PROTOBUF_NAMESPACE_ID::Timestamp* _internal_mutable_reporttime();
  public:
  void unsafe_arena_set_allocated_reporttime(
      ::PROTOBUF_NAMESPACE_ID::Timestamp* reporttime);
  ::PROTOBUF_NAMESPACE_ID::Timestamp* unsafe_arena_release_reporttime();

  // uint32 Id = 1;
  void clear_id();
  uint32_t id() const;
  void set_id(uint32_t value);
  private:
  uint32_t _internal_id() const;
  void _internal_set_id(uint32_t value);
  public:

  // uint32 AlarmID = 2;
  void clear_alarmid();
  uint32_t alarmid() const;
  void set_alarmid(uint32_t value);
  private:
  uint32_t _internal_alarmid() const;
  void _internal_set_alarmid(uint32_t value);
  public:

  // uint32 StationID = 3;
  void clear_stationid();
  uint32_t stationid() const;
  void set_stationid(uint32_t value);
  private:
  uint32_t _internal_stationid() const;
  void _internal_set_stationid(uint32_t value);
  public:

  // uint32 DeviceID = 4;
  void clear_deviceid();
  uint32_t deviceid() const;
  void set_deviceid(uint32_t value);
  private:
  uint32_t _internal_deviceid() const;
  void _internal_set_deviceid(uint32_t value);
  public:

  // .Level AlarmLevel = 5;
  void clear_alarmlevel();
  ::Level alarmlevel() const;
  void set_alarmlevel(::Level value);
  private:
  ::Level _internal_alarmlevel() const;
  void _internal_set_alarmlevel(::Level value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr alarmdescriptionchn_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr alarmdescriptioneng_;
  ::PROTOBUF_NAMESPACE_ID::Timestamp* reporttime_;
  uint32_t id_;
  uint32_t alarmid_;
  uint32_t stationid_;
  uint32_t deviceid_;
  int alarmlevel_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_OAM_5fdatastruct_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "HisAlarm";
  }
  protected:
  explicit HisAlarm(::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 {
    kAlarmDescriptionCHNFieldNumber = 6,
    kAlarmDescriptionENGFieldNumber = 7,
    kStartTimeFieldNumber = 8,
    kEndTimeFieldNumber = 9,
    kIdFieldNumber = 1,
    kAlarmIDFieldNumber = 2,
    kStationIDFieldNumber = 3,
    kDeviceIDFieldNumber = 4,
    kAlarmLevelFieldNumber = 5,
  };
  // string AlarmDescriptionCHN = 6;
  void clear_alarmdescriptionchn();
  const std::string& alarmdescriptionchn() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_alarmdescriptionchn(ArgT0&& arg0, ArgT... args);
  std::string* mutable_alarmdescriptionchn();
  PROTOBUF_NODISCARD std::string* release_alarmdescriptionchn();
  void set_allocated_alarmdescriptionchn(std::string* alarmdescriptionchn);
  private:
  const std::string& _internal_alarmdescriptionchn() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_alarmdescriptionchn(const std::string& value);
  std::string* _internal_mutable_alarmdescriptionchn();
  public:

  // string AlarmDescriptionENG = 7;
  void clear_alarmdescriptioneng();
  const std::string& alarmdescriptioneng() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_alarmdescriptioneng(ArgT0&& arg0, ArgT... args);
  std::string* mutable_alarmdescriptioneng();
  PROTOBUF_NODISCARD std::string* release_alarmdescriptioneng();
  void set_allocated_alarmdescriptioneng(std::string* alarmdescriptioneng);
  private:
  const std::string& _internal_alarmdescriptioneng() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_alarmdescriptioneng(const std::string& value);
  std::string* _internal_mutable_alarmdescriptioneng();
  public:

  // .google.protobuf.Timestamp StartTime = 8;
  bool has_starttime() const;
  private:
  bool _internal_has_starttime() const;
  public:
  void clear_starttime();
  const ::PROTOBUF_NAMESPACE_ID::Timestamp& starttime() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Timestamp* release_starttime();
  ::PROTOBUF_NAMESPACE_ID::Timestamp* mutable_starttime();
  void set_allocated_starttime(::PROTOBUF_NAMESPACE_ID::Timestamp* starttime);
  private:
  const ::PROTOBUF_NAMESPACE_ID::Timestamp& _internal_starttime() const;
  ::PROTOBUF_NAMESPACE_ID::Timestamp* _internal_mutable_starttime();
  public:
  void unsafe_arena_set_allocated_starttime(
      ::PROTOBUF_NAMESPACE_ID::Timestamp* starttime);
  ::PROTOBUF_NAMESPACE_ID::Timestamp* unsafe_arena_release_starttime();

  // .google.protobuf.Timestamp EndTime = 9;
  bool has_endtime() const;
  private:
  bool _internal_has_endtime() const;
  public:
  void clear_endtime();
  const ::PROTOBUF_NAMESPACE_ID::Timestamp& endtime() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Timestamp* release_endtime();
  ::PROTOBUF_NAMESPACE_ID::Timestamp* mutable_endtime();
  void set_allocated_endtime(::PROTOBUF_NAMESPACE_ID::Timestamp* endtime);
  private:
  const ::PROTOBUF_NAMESPACE_ID::Timestamp& _internal_endtime() const;
  ::PROTOBUF_NAMESPACE_ID::Timestamp* _internal_mutable_endtime();
  public:
  void unsafe_arena_set_allocated_endtime(
      ::PROTOBUF_NAMESPACE_ID::Timestamp* endtime);
  ::PROTOBUF_NAMESPACE_ID::Timestamp* unsafe_arena_release_endtime();

  // uint32 Id = 1;
  void clear_id();
  uint32_t id() const;
  void set_id(uint32_t value);
  private:
  uint32_t _internal_id() const;
  void _internal_set_id(uint32_t value);
  public:

  // uint32 AlarmID = 2;
  void clear_alarmid();
  uint32_t alarmid() const;
  void set_alarmid(uint32_t value);
  private:
  uint32_t _internal_alarmid() const;
  void _internal_set_alarmid(uint32_t value);
  public:

  // uint32 StationID = 3;
  void clear_stationid();
  uint32_t stationid() const;
  void set_stationid(uint32_t value);
  private:
  uint32_t _internal_stationid() const;
  void _internal_set_stationid(uint32_t value);
  public:

  // uint32 DeviceID = 4;
  void clear_deviceid();
  uint32_t deviceid() const;
  void set_deviceid(uint32_t value);
  private:
  uint32_t _internal_deviceid() const;
  void _internal_set_deviceid(uint32_t value);
  public:

  // .Level AlarmLevel = 5;
  void clear_alarmlevel();
  ::Level alarmlevel() const;
  void set_alarmlevel(::Level value);
  private:
  ::Level _internal_alarmlevel() const;
  void _internal_set_alarmlevel(::Level value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr alarmdescriptionchn_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr alarmdescriptioneng_;
  ::PROTOBUF_NAMESPACE_ID::Timestamp* starttime_;
  ::PROTOBUF_NAMESPACE_ID::Timestamp* endtime_;
  uint32_t id_;
  uint32_t alarmid_;
  uint32_t stationid_;
  uint32_t deviceid_;
  int alarmlevel_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_OAM_5fdatastruct_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "SysStatus";
  }
  protected:
  explicit SysStatus(::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 {
    kReportTimeFieldNumber = 4,
    kStationIDFieldNumber = 1,
    kDeviceIDFieldNumber = 2,
    kStatusFieldNumber = 3,
  };
  // .google.protobuf.Timestamp ReportTime = 4;
  bool has_reporttime() const;
  private:
  bool _internal_has_reporttime() const;
  public:
  void clear_reporttime();
  const ::PROTOBUF_NAMESPACE_ID::Timestamp& reporttime() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Timestamp* release_reporttime();
  ::PROTOBUF_NAMESPACE_ID::Timestamp* mutable_reporttime();
  void set_allocated_reporttime(::PROTOBUF_NAMESPACE_ID::Timestamp* reporttime);
  private:
  const ::PROTOBUF_NAMESPACE_ID::Timestamp& _internal_reporttime() const;
  ::PROTOBUF_NAMESPACE_ID::Timestamp* _internal_mutable_reporttime();
  public:
  void unsafe_arena_set_allocated_reporttime(
      ::PROTOBUF_NAMESPACE_ID::Timestamp* reporttime);
  ::PROTOBUF_NAMESPACE_ID::Timestamp* unsafe_arena_release_reporttime();

  // uint32 StationID = 1;
  void clear_stationid();
  uint32_t stationid() const;
  void set_stationid(uint32_t value);
  private:
  uint32_t _internal_stationid() const;
  void _internal_set_stationid(uint32_t value);
  public:

  // uint32 DeviceID = 2;
  void clear_deviceid();
  uint32_t deviceid() const;
  void set_deviceid(uint32_t value);
  private:
  uint32_t _internal_deviceid() const;
  void _internal_set_deviceid(uint32_t value);
  public:

  // .Devistatus Status = 3;
  void clear_status();
  ::Devistatus status() const;
  void set_status(::Devistatus value);
  private:
  ::Devistatus _internal_status() const;
  void _internal_set_status(::Devistatus value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::Timestamp* reporttime_;
  uint32_t stationid_;
  uint32_t deviceid_;
  int status_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_OAM_5fdatastruct_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Log";
  }
  protected:
  explicit Log(::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 {
    kLogInfoCHNFieldNumber = 4,
    kLogInfoENGFieldNumber = 5,
    kManipunatorFieldNumber = 6,
    kReportTimeFieldNumber = 7,
    kStationIDFieldNumber = 1,
    kDeviceIDFieldNumber = 2,
    kLoglevelFieldNumber = 3,
  };
  // string LogInfoCHN = 4;
  void clear_loginfochn();
  const std::string& loginfochn() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_loginfochn(ArgT0&& arg0, ArgT... args);
  std::string* mutable_loginfochn();
  PROTOBUF_NODISCARD std::string* release_loginfochn();
  void set_allocated_loginfochn(std::string* loginfochn);
  private:
  const std::string& _internal_loginfochn() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_loginfochn(const std::string& value);
  std::string* _internal_mutable_loginfochn();
  public:

  // string LogInfoENG = 5;
  void clear_loginfoeng();
  const std::string& loginfoeng() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_loginfoeng(ArgT0&& arg0, ArgT... args);
  std::string* mutable_loginfoeng();
  PROTOBUF_NODISCARD std::string* release_loginfoeng();
  void set_allocated_loginfoeng(std::string* loginfoeng);
  private:
  const std::string& _internal_loginfoeng() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_loginfoeng(const std::string& value);
  std::string* _internal_mutable_loginfoeng();
  public:

  // string Manipunator = 6;
  void clear_manipunator();
  const std::string& manipunator() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_manipunator(ArgT0&& arg0, ArgT... args);
  std::string* mutable_manipunator();
  PROTOBUF_NODISCARD std::string* release_manipunator();
  void set_allocated_manipunator(std::string* manipunator);
  private:
  const std::string& _internal_manipunator() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_manipunator(const std::string& value);
  std::string* _internal_mutable_manipunator();
  public:

  // .google.protobuf.Timestamp ReportTime = 7;
  bool has_reporttime() const;
  private:
  bool _internal_has_reporttime() const;
  public:
  void clear_reporttime();
  const ::PROTOBUF_NAMESPACE_ID::Timestamp& reporttime() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Timestamp* release_reporttime();
  ::PROTOBUF_NAMESPACE_ID::Timestamp* mutable_reporttime();
  void set_allocated_reporttime(::PROTOBUF_NAMESPACE_ID::Timestamp* reporttime);
  private:
  const ::PROTOBUF_NAMESPACE_ID::Timestamp& _internal_reporttime() const;
  ::PROTOBUF_NAMESPACE_ID::Timestamp* _internal_mutable_reporttime();
  public:
  void unsafe_arena_set_allocated_reporttime(
      ::PROTOBUF_NAMESPACE_ID::Timestamp* reporttime);
  ::PROTOBUF_NAMESPACE_ID::Timestamp* unsafe_arena_release_reporttime();

  // uint32 StationID = 1;
  void clear_stationid();
  uint32_t stationid() const;
  void set_stationid(uint32_t value);
  private:
  uint32_t _internal_stationid() const;
  void _internal_set_stationid(uint32_t value);
  public:

  // uint32 DeviceID = 2;
  void clear_deviceid();
  uint32_t deviceid() const;
  void set_deviceid(uint32_t value);
  private:
  uint32_t _internal_deviceid() const;
  void _internal_set_deviceid(uint32_t value);
  public:

  // .LogLevel Loglevel = 3;
  void clear_loglevel();
  ::LogLevel loglevel() const;
  void set_loglevel(::LogLevel value);
  private:
  ::LogLevel _internal_loglevel() const;
  void _internal_set_loglevel(::LogLevel value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr loginfochn_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr loginfoeng_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr manipunator_;
  ::PROTOBUF_NAMESPACE_ID::Timestamp* reporttime_;
  uint32_t stationid_;
  uint32_t deviceid_;
  int loglevel_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_OAM_5fdatastruct_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "PerInfo";
  }
  protected:
  explicit PerInfo(::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 {
    kDataCatlogFieldNumber = 5,
    kFieldNameFieldNumber = 6,
    kFieldValueFieldNumber = 7,
    kPerDescriptionCHNFieldNumber = 8,
    kPerDescriptionENGFieldNumber = 9,
    kUpdateTimeFieldNumber = 10,
    kIdFieldNumber = 1,
    kPerIDFieldNumber = 2,
    kStationIDFieldNumber = 3,
    kDeviceIDFieldNumber = 4,
  };
  // string DataCatlog = 5;
  void clear_datacatlog();
  const std::string& datacatlog() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_datacatlog(ArgT0&& arg0, ArgT... args);
  std::string* mutable_datacatlog();
  PROTOBUF_NODISCARD std::string* release_datacatlog();
  void set_allocated_datacatlog(std::string* datacatlog);
  private:
  const std::string& _internal_datacatlog() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_datacatlog(const std::string& value);
  std::string* _internal_mutable_datacatlog();
  public:

  // string FieldName = 6;
  void clear_fieldname();
  const std::string& fieldname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fieldname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fieldname();
  PROTOBUF_NODISCARD std::string* release_fieldname();
  void set_allocated_fieldname(std::string* fieldname);
  private:
  const std::string& _internal_fieldname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fieldname(const std::string& value);
  std::string* _internal_mutable_fieldname();
  public:

  // string FieldValue = 7;
  void clear_fieldvalue();
  const std::string& fieldvalue() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fieldvalue(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fieldvalue();
  PROTOBUF_NODISCARD std::string* release_fieldvalue();
  void set_allocated_fieldvalue(std::string* fieldvalue);
  private:
  const std::string& _internal_fieldvalue() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fieldvalue(const std::string& value);
  std::string* _internal_mutable_fieldvalue();
  public:

  // string PerDescriptionCHN = 8;
  void clear_perdescriptionchn();
  const std::string& perdescriptionchn() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_perdescriptionchn(ArgT0&& arg0, ArgT... args);
  std::string* mutable_perdescriptionchn();
  PROTOBUF_NODISCARD std::string* release_perdescriptionchn();
  void set_allocated_perdescriptionchn(std::string* perdescriptionchn);
  private:
  const std::string& _internal_perdescriptionchn() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_perdescriptionchn(const std::string& value);
  std::string* _internal_mutable_perdescriptionchn();
  public:

  // string PerDescriptionENG = 9;
  void clear_perdescriptioneng();
  const std::string& perdescriptioneng() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_perdescriptioneng(ArgT0&& arg0, ArgT... args);
  std::string* mutable_perdescriptioneng();
  PROTOBUF_NODISCARD std::string* release_perdescriptioneng();
  void set_allocated_perdescriptioneng(std::string* perdescriptioneng);
  private:
  const std::string& _internal_perdescriptioneng() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_perdescriptioneng(const std::string& value);
  std::string* _internal_mutable_perdescriptioneng();
  public:

  // .google.protobuf.Timestamp UpdateTime = 10;
  bool has_updatetime() const;
  private:
  bool _internal_has_updatetime() const;
  public:
  void clear_updatetime();
  const ::PROTOBUF_NAMESPACE_ID::Timestamp& updatetime() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Timestamp* release_updatetime();
  ::PROTOBUF_NAMESPACE_ID::Timestamp* mutable_updatetime();
  void set_allocated_updatetime(::PROTOBUF_NAMESPACE_ID::Timestamp* updatetime);
  private:
  const ::PROTOBUF_NAMESPACE_ID::Timestamp& _internal_updatetime() const;
  ::PROTOBUF_NAMESPACE_ID::Timestamp* _internal_mutable_updatetime();
  public:
  void unsafe_arena_set_allocated_updatetime(
      ::PROTOBUF_NAMESPACE_ID::Timestamp* updatetime);
  ::PROTOBUF_NAMESPACE_ID::Timestamp* unsafe_arena_release_updatetime();

  // uint32 Id = 1;
  void clear_id();
  uint32_t id() const;
  void set_id(uint32_t value);
  private:
  uint32_t _internal_id() const;
  void _internal_set_id(uint32_t value);
  public:

  // uint32 PerID = 2;
  void clear_perid();
  uint32_t perid() const;
  void set_perid(uint32_t value);
  private:
  uint32_t _internal_perid() const;
  void _internal_set_perid(uint32_t value);
  public:

  // uint32 StationID = 3;
  void clear_stationid();
  uint32_t stationid() const;
  void set_stationid(uint32_t value);
  private:
  uint32_t _internal_stationid() const;
  void _internal_set_stationid(uint32_t value);
  public:

  // uint32 DeviceID = 4;
  void clear_deviceid();
  uint32_t deviceid() const;
  void set_deviceid(uint32_t value);
  private:
  uint32_t _internal_deviceid() const;
  void _internal_set_deviceid(uint32_t value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr datacatlog_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fieldname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fieldvalue_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr perdescriptionchn_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr perdescriptioneng_;
  ::PROTOBUF_NAMESPACE_ID::Timestamp* updatetime_;
  uint32_t id_;
  uint32_t perid_;
  uint32_t stationid_;
  uint32_t deviceid_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_OAM_5fdatastruct_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "PerRequire";
  }
  protected:
  explicit PerRequire(::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 {
    kDataCatlogFieldNumber = 1,
    kFieldNameFieldNumber = 2,
    kIsMonFieldNumber = 3,
  };
  // string DataCatlog = 1;
  void clear_datacatlog();
  const std::string& datacatlog() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_datacatlog(ArgT0&& arg0, ArgT... args);
  std::string* mutable_datacatlog();
  PROTOBUF_NODISCARD std::string* release_datacatlog();
  void set_allocated_datacatlog(std::string* datacatlog);
  private:
  const std::string& _internal_datacatlog() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_datacatlog(const std::string& value);
  std::string* _internal_mutable_datacatlog();
  public:

  // string FieldName = 2;
  void clear_fieldname();
  const std::string& fieldname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fieldname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fieldname();
  PROTOBUF_NODISCARD std::string* release_fieldname();
  void set_allocated_fieldname(std::string* fieldname);
  private:
  const std::string& _internal_fieldname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fieldname(const std::string& value);
  std::string* _internal_mutable_fieldname();
  public:

  // uint32 IsMon = 3;
  void clear_ismon();
  uint32_t ismon() const;
  void set_ismon(uint32_t value);
  private:
  uint32_t _internal_ismon() const;
  void _internal_set_ismon(uint32_t value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr datacatlog_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fieldname_;
  uint32_t ismon_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_OAM_5fdatastruct_2eproto;
};
// ===================================================================


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

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

// uint32 AlarmID = 1;
inline void DeviceRet::clear_alarmid() {
  alarmid_ = 0u;
}
inline uint32_t DeviceRet::_internal_alarmid() const {
  return alarmid_;
}
inline uint32_t DeviceRet::alarmid() const {
  // @@protoc_insertion_point(field_get:DeviceRet.AlarmID)
  return _internal_alarmid();
}
inline void DeviceRet::_internal_set_alarmid(uint32_t value) {
  
  alarmid_ = value;
}
inline void DeviceRet::set_alarmid(uint32_t value) {
  _internal_set_alarmid(value);
  // @@protoc_insertion_point(field_set:DeviceRet.AlarmID)
}

// uint32 StationID = 2;
inline void DeviceRet::clear_stationid() {
  stationid_ = 0u;
}
inline uint32_t DeviceRet::_internal_stationid() const {
  return stationid_;
}
inline uint32_t DeviceRet::stationid() const {
  // @@protoc_insertion_point(field_get:DeviceRet.StationID)
  return _internal_stationid();
}
inline void DeviceRet::_internal_set_stationid(uint32_t value) {
  
  stationid_ = value;
}
inline void DeviceRet::set_stationid(uint32_t value) {
  _internal_set_stationid(value);
  // @@protoc_insertion_point(field_set:DeviceRet.StationID)
}

// uint32 DeviceID = 3;
inline void DeviceRet::clear_deviceid() {
  deviceid_ = 0u;
}
inline uint32_t DeviceRet::_internal_deviceid() const {
  return deviceid_;
}
inline uint32_t DeviceRet::deviceid() const {
  // @@protoc_insertion_point(field_get:DeviceRet.DeviceID)
  return _internal_deviceid();
}
inline void DeviceRet::_internal_set_deviceid(uint32_t value) {
  
  deviceid_ = value;
}
inline void DeviceRet::set_deviceid(uint32_t value) {
  _internal_set_deviceid(value);
  // @@protoc_insertion_point(field_set:DeviceRet.DeviceID)
}

// .CodeValue CodeRet = 4;
inline void DeviceRet::clear_coderet() {
  coderet_ = 0;
}
inline ::CodeValue DeviceRet::_internal_coderet() const {
  return static_cast< ::CodeValue >(coderet_);
}
inline ::CodeValue DeviceRet::coderet() const {
  // @@protoc_insertion_point(field_get:DeviceRet.CodeRet)
  return _internal_coderet();
}
inline void DeviceRet::_internal_set_coderet(::CodeValue value) {
  
  coderet_ = value;
}
inline void DeviceRet::set_coderet(::CodeValue value) {
  _internal_set_coderet(value);
  // @@protoc_insertion_point(field_set:DeviceRet.CodeRet)
}

// string Message = 5;
inline void DeviceRet::clear_message() {
  message_.ClearToEmpty();
}
inline const std::string& DeviceRet::message() const {
  // @@protoc_insertion_point(field_get:DeviceRet.Message)
  return _internal_message();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceRet::set_message(ArgT0&& arg0, ArgT... args) {
 
 message_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:DeviceRet.Message)
}
inline std::string* DeviceRet::mutable_message() {
  std::string* _s = _internal_mutable_message();
  // @@protoc_insertion_point(field_mutable:DeviceRet.Message)
  return _s;
}
inline const std::string& DeviceRet::_internal_message() const {
  return message_.Get();
}
inline void DeviceRet::_internal_set_message(const std::string& value) {
  
  message_.Set(value, GetArenaForAllocation());
}
inline std::string* DeviceRet::_internal_mutable_message() {
  
  return message_.Mutable(GetArenaForAllocation());
}
inline std::string* DeviceRet::release_message() {
  // @@protoc_insertion_point(field_release:DeviceRet.Message)
  return message_.Release();
}
inline void DeviceRet::set_allocated_message(std::string* message) {
  if (message != nullptr) {
    
  } else {
    
  }
  message_.SetAllocated(message, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (message_.IsDefault()) {
    message_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:DeviceRet.Message)
}

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

// Respond

// .CodeValue CodeRet = 1;
inline void Respond::clear_coderet() {
  coderet_ = 0;
}
inline ::CodeValue Respond::_internal_coderet() const {
  return static_cast< ::CodeValue >(coderet_);
}
inline ::CodeValue Respond::coderet() const {
  // @@protoc_insertion_point(field_get:Respond.CodeRet)
  return _internal_coderet();
}
inline void Respond::_internal_set_coderet(::CodeValue value) {
  
  coderet_ = value;
}
inline void Respond::set_coderet(::CodeValue value) {
  _internal_set_coderet(value);
  // @@protoc_insertion_point(field_set:Respond.CodeRet)
}

// string Message = 2;
inline void Respond::clear_message() {
  message_.ClearToEmpty();
}
inline const std::string& Respond::message() const {
  // @@protoc_insertion_point(field_get:Respond.Message)
  return _internal_message();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Respond::set_message(ArgT0&& arg0, ArgT... args) {
 
 message_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Respond.Message)
}
inline std::string* Respond::mutable_message() {
  std::string* _s = _internal_mutable_message();
  // @@protoc_insertion_point(field_mutable:Respond.Message)
  return _s;
}
inline const std::string& Respond::_internal_message() const {
  return message_.Get();
}
inline void Respond::_internal_set_message(const std::string& value) {
  
  message_.Set(value, GetArenaForAllocation());
}
inline std::string* Respond::_internal_mutable_message() {
  
  return message_.Mutable(GetArenaForAllocation());
}
inline std::string* Respond::release_message() {
  // @@protoc_insertion_point(field_release:Respond.Message)
  return message_.Release();
}
inline void Respond::set_allocated_message(std::string* message) {
  if (message != nullptr) {
    
  } else {
    
  }
  message_.SetAllocated(message, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (message_.IsDefault()) {
    message_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Respond.Message)
}

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

// StationDevID

// uint32 StationID = 1;
inline void StationDevID::clear_stationid() {
  stationid_ = 0u;
}
inline uint32_t StationDevID::_internal_stationid() const {
  return stationid_;
}
inline uint32_t StationDevID::stationid() const {
  // @@protoc_insertion_point(field_get:StationDevID.StationID)
  return _internal_stationid();
}
inline void StationDevID::_internal_set_stationid(uint32_t value) {
  
  stationid_ = value;
}
inline void StationDevID::set_stationid(uint32_t value) {
  _internal_set_stationid(value);
  // @@protoc_insertion_point(field_set:StationDevID.StationID)
}

// uint32 DeviceID = 2;
inline void StationDevID::clear_deviceid() {
  deviceid_ = 0u;
}
inline uint32_t StationDevID::_internal_deviceid() const {
  return deviceid_;
}
inline uint32_t StationDevID::deviceid() const {
  // @@protoc_insertion_point(field_get:StationDevID.DeviceID)
  return _internal_deviceid();
}
inline void StationDevID::_internal_set_deviceid(uint32_t value) {
  
  deviceid_ = value;
}
inline void StationDevID::set_deviceid(uint32_t value) {
  _internal_set_deviceid(value);
  // @@protoc_insertion_point(field_set:StationDevID.DeviceID)
}

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

// AlarmAttri

// uint32 Id = 1;
inline void AlarmAttri::clear_id() {
  id_ = 0u;
}
inline uint32_t AlarmAttri::_internal_id() const {
  return id_;
}
inline uint32_t AlarmAttri::id() const {
  // @@protoc_insertion_point(field_get:AlarmAttri.Id)
  return _internal_id();
}
inline void AlarmAttri::_internal_set_id(uint32_t value) {
  
  id_ = value;
}
inline void AlarmAttri::set_id(uint32_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:AlarmAttri.Id)
}

// uint32 AlarmID = 2;
inline void AlarmAttri::clear_alarmid() {
  alarmid_ = 0u;
}
inline uint32_t AlarmAttri::_internal_alarmid() const {
  return alarmid_;
}
inline uint32_t AlarmAttri::alarmid() const {
  // @@protoc_insertion_point(field_get:AlarmAttri.AlarmID)
  return _internal_alarmid();
}
inline void AlarmAttri::_internal_set_alarmid(uint32_t value) {
  
  alarmid_ = value;
}
inline void AlarmAttri::set_alarmid(uint32_t value) {
  _internal_set_alarmid(value);
  // @@protoc_insertion_point(field_set:AlarmAttri.AlarmID)
}

// .Level AlarmLevel = 3;
inline void AlarmAttri::clear_alarmlevel() {
  alarmlevel_ = 0;
}
inline ::Level AlarmAttri::_internal_alarmlevel() const {
  return static_cast< ::Level >(alarmlevel_);
}
inline ::Level AlarmAttri::alarmlevel() const {
  // @@protoc_insertion_point(field_get:AlarmAttri.AlarmLevel)
  return _internal_alarmlevel();
}
inline void AlarmAttri::_internal_set_alarmlevel(::Level value) {
  
  alarmlevel_ = value;
}
inline void AlarmAttri::set_alarmlevel(::Level value) {
  _internal_set_alarmlevel(value);
  // @@protoc_insertion_point(field_set:AlarmAttri.AlarmLevel)
}

// string AlarmDescriptionCHN = 4;
inline void AlarmAttri::clear_alarmdescriptionchn() {
  alarmdescriptionchn_.ClearToEmpty();
}
inline const std::string& AlarmAttri::alarmdescriptionchn() const {
  // @@protoc_insertion_point(field_get:AlarmAttri.AlarmDescriptionCHN)
  return _internal_alarmdescriptionchn();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AlarmAttri::set_alarmdescriptionchn(ArgT0&& arg0, ArgT... args) {
 
 alarmdescriptionchn_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:AlarmAttri.AlarmDescriptionCHN)
}
inline std::string* AlarmAttri::mutable_alarmdescriptionchn() {
  std::string* _s = _internal_mutable_alarmdescriptionchn();
  // @@protoc_insertion_point(field_mutable:AlarmAttri.AlarmDescriptionCHN)
  return _s;
}
inline const std::string& AlarmAttri::_internal_alarmdescriptionchn() const {
  return alarmdescriptionchn_.Get();
}
inline void AlarmAttri::_internal_set_alarmdescriptionchn(const std::string& value) {
  
  alarmdescriptionchn_.Set(value, GetArenaForAllocation());
}
inline std::string* AlarmAttri::_internal_mutable_alarmdescriptionchn() {
  
  return alarmdescriptionchn_.Mutable(GetArenaForAllocation());
}
inline std::string* AlarmAttri::release_alarmdescriptionchn() {
  // @@protoc_insertion_point(field_release:AlarmAttri.AlarmDescriptionCHN)
  return alarmdescriptionchn_.Release();
}
inline void AlarmAttri::set_allocated_alarmdescriptionchn(std::string* alarmdescriptionchn) {
  if (alarmdescriptionchn != nullptr) {
    
  } else {
    
  }
  alarmdescriptionchn_.SetAllocated(alarmdescriptionchn, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (alarmdescriptionchn_.IsDefault()) {
    alarmdescriptionchn_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:AlarmAttri.AlarmDescriptionCHN)
}

// string AlarmDescriptionENG = 5;
inline void AlarmAttri::clear_alarmdescriptioneng() {
  alarmdescriptioneng_.ClearToEmpty();
}
inline const std::string& AlarmAttri::alarmdescriptioneng() const {
  // @@protoc_insertion_point(field_get:AlarmAttri.AlarmDescriptionENG)
  return _internal_alarmdescriptioneng();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AlarmAttri::set_alarmdescriptioneng(ArgT0&& arg0, ArgT... args) {
 
 alarmdescriptioneng_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:AlarmAttri.AlarmDescriptionENG)
}
inline std::string* AlarmAttri::mutable_alarmdescriptioneng() {
  std::string* _s = _internal_mutable_alarmdescriptioneng();
  // @@protoc_insertion_point(field_mutable:AlarmAttri.AlarmDescriptionENG)
  return _s;
}
inline const std::string& AlarmAttri::_internal_alarmdescriptioneng() const {
  return alarmdescriptioneng_.Get();
}
inline void AlarmAttri::_internal_set_alarmdescriptioneng(const std::string& value) {
  
  alarmdescriptioneng_.Set(value, GetArenaForAllocation());
}
inline std::string* AlarmAttri::_internal_mutable_alarmdescriptioneng() {
  
  return alarmdescriptioneng_.Mutable(GetArenaForAllocation());
}
inline std::string* AlarmAttri::release_alarmdescriptioneng() {
  // @@protoc_insertion_point(field_release:AlarmAttri.AlarmDescriptionENG)
  return alarmdescriptioneng_.Release();
}
inline void AlarmAttri::set_allocated_alarmdescriptioneng(std::string* alarmdescriptioneng) {
  if (alarmdescriptioneng != nullptr) {
    
  } else {
    
  }
  alarmdescriptioneng_.SetAllocated(alarmdescriptioneng, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (alarmdescriptioneng_.IsDefault()) {
    alarmdescriptioneng_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:AlarmAttri.AlarmDescriptionENG)
}

// uint32 IsMon = 6;
inline void AlarmAttri::clear_ismon() {
  ismon_ = 0u;
}
inline uint32_t AlarmAttri::_internal_ismon() const {
  return ismon_;
}
inline uint32_t AlarmAttri::ismon() const {
  // @@protoc_insertion_point(field_get:AlarmAttri.IsMon)
  return _internal_ismon();
}
inline void AlarmAttri::_internal_set_ismon(uint32_t value) {
  
  ismon_ = value;
}
inline void AlarmAttri::set_ismon(uint32_t value) {
  _internal_set_ismon(value);
  // @@protoc_insertion_point(field_set:AlarmAttri.IsMon)
}

// .google.protobuf.Timestamp CreateTime = 7;
inline bool AlarmAttri::_internal_has_createtime() const {
  return this != internal_default_instance() && createtime_ != nullptr;
}
inline bool AlarmAttri::has_createtime() const {
  return _internal_has_createtime();
}
inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& AlarmAttri::_internal_createtime() const {
  const ::PROTOBUF_NAMESPACE_ID::Timestamp* p = createtime_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Timestamp&>(
      ::PROTOBUF_NAMESPACE_ID::_Timestamp_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& AlarmAttri::createtime() const {
  // @@protoc_insertion_point(field_get:AlarmAttri.CreateTime)
  return _internal_createtime();
}
inline void AlarmAttri::unsafe_arena_set_allocated_createtime(
    ::PROTOBUF_NAMESPACE_ID::Timestamp* createtime) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(createtime_);
  }
  createtime_ = createtime;
  if (createtime) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:AlarmAttri.CreateTime)
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* AlarmAttri::release_createtime() {
  
  ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = createtime_;
  createtime_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* AlarmAttri::unsafe_arena_release_createtime() {
  // @@protoc_insertion_point(field_release:AlarmAttri.CreateTime)
  
  ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = createtime_;
  createtime_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* AlarmAttri::_internal_mutable_createtime() {
  
  if (createtime_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Timestamp>(GetArenaForAllocation());
    createtime_ = p;
  }
  return createtime_;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* AlarmAttri::mutable_createtime() {
  ::PROTOBUF_NAMESPACE_ID::Timestamp* _msg = _internal_mutable_createtime();
  // @@protoc_insertion_point(field_mutable:AlarmAttri.CreateTime)
  return _msg;
}
inline void AlarmAttri::set_allocated_createtime(::PROTOBUF_NAMESPACE_ID::Timestamp* createtime) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(createtime_);
  }
  if (createtime) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(createtime));
    if (message_arena != submessage_arena) {
      createtime = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, createtime, submessage_arena);
    }
    
  } else {
    
  }
  createtime_ = createtime;
  // @@protoc_insertion_point(field_set_allocated:AlarmAttri.CreateTime)
}

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

// PerAttri

// uint32 Id = 1;
inline void PerAttri::clear_id() {
  id_ = 0u;
}
inline uint32_t PerAttri::_internal_id() const {
  return id_;
}
inline uint32_t PerAttri::id() const {
  // @@protoc_insertion_point(field_get:PerAttri.Id)
  return _internal_id();
}
inline void PerAttri::_internal_set_id(uint32_t value) {
  
  id_ = value;
}
inline void PerAttri::set_id(uint32_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:PerAttri.Id)
}

// uint32 PerID = 2;
inline void PerAttri::clear_perid() {
  perid_ = 0u;
}
inline uint32_t PerAttri::_internal_perid() const {
  return perid_;
}
inline uint32_t PerAttri::perid() const {
  // @@protoc_insertion_point(field_get:PerAttri.PerID)
  return _internal_perid();
}
inline void PerAttri::_internal_set_perid(uint32_t value) {
  
  perid_ = value;
}
inline void PerAttri::set_perid(uint32_t value) {
  _internal_set_perid(value);
  // @@protoc_insertion_point(field_set:PerAttri.PerID)
}

// string DataCatlog = 3;
inline void PerAttri::clear_datacatlog() {
  datacatlog_.ClearToEmpty();
}
inline const std::string& PerAttri::datacatlog() const {
  // @@protoc_insertion_point(field_get:PerAttri.DataCatlog)
  return _internal_datacatlog();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PerAttri::set_datacatlog(ArgT0&& arg0, ArgT... args) {
 
 datacatlog_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:PerAttri.DataCatlog)
}
inline std::string* PerAttri::mutable_datacatlog() {
  std::string* _s = _internal_mutable_datacatlog();
  // @@protoc_insertion_point(field_mutable:PerAttri.DataCatlog)
  return _s;
}
inline const std::string& PerAttri::_internal_datacatlog() const {
  return datacatlog_.Get();
}
inline void PerAttri::_internal_set_datacatlog(const std::string& value) {
  
  datacatlog_.Set(value, GetArenaForAllocation());
}
inline std::string* PerAttri::_internal_mutable_datacatlog() {
  
  return datacatlog_.Mutable(GetArenaForAllocation());
}
inline std::string* PerAttri::release_datacatlog() {
  // @@protoc_insertion_point(field_release:PerAttri.DataCatlog)
  return datacatlog_.Release();
}
inline void PerAttri::set_allocated_datacatlog(std::string* datacatlog) {
  if (datacatlog != nullptr) {
    
  } else {
    
  }
  datacatlog_.SetAllocated(datacatlog, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (datacatlog_.IsDefault()) {
    datacatlog_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:PerAttri.DataCatlog)
}

// string FieldName = 4;
inline void PerAttri::clear_fieldname() {
  fieldname_.ClearToEmpty();
}
inline const std::string& PerAttri::fieldname() const {
  // @@protoc_insertion_point(field_get:PerAttri.FieldName)
  return _internal_fieldname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PerAttri::set_fieldname(ArgT0&& arg0, ArgT... args) {
 
 fieldname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:PerAttri.FieldName)
}
inline std::string* PerAttri::mutable_fieldname() {
  std::string* _s = _internal_mutable_fieldname();
  // @@protoc_insertion_point(field_mutable:PerAttri.FieldName)
  return _s;
}
inline const std::string& PerAttri::_internal_fieldname() const {
  return fieldname_.Get();
}
inline void PerAttri::_internal_set_fieldname(const std::string& value) {
  
  fieldname_.Set(value, GetArenaForAllocation());
}
inline std::string* PerAttri::_internal_mutable_fieldname() {
  
  return fieldname_.Mutable(GetArenaForAllocation());
}
inline std::string* PerAttri::release_fieldname() {
  // @@protoc_insertion_point(field_release:PerAttri.FieldName)
  return fieldname_.Release();
}
inline void PerAttri::set_allocated_fieldname(std::string* fieldname) {
  if (fieldname != nullptr) {
    
  } else {
    
  }
  fieldname_.SetAllocated(fieldname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (fieldname_.IsDefault()) {
    fieldname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:PerAttri.FieldName)
}

// string PerDescriptionCHN = 5;
inline void PerAttri::clear_perdescriptionchn() {
  perdescriptionchn_.ClearToEmpty();
}
inline const std::string& PerAttri::perdescriptionchn() const {
  // @@protoc_insertion_point(field_get:PerAttri.PerDescriptionCHN)
  return _internal_perdescriptionchn();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PerAttri::set_perdescriptionchn(ArgT0&& arg0, ArgT... args) {
 
 perdescriptionchn_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:PerAttri.PerDescriptionCHN)
}
inline std::string* PerAttri::mutable_perdescriptionchn() {
  std::string* _s = _internal_mutable_perdescriptionchn();
  // @@protoc_insertion_point(field_mutable:PerAttri.PerDescriptionCHN)
  return _s;
}
inline const std::string& PerAttri::_internal_perdescriptionchn() const {
  return perdescriptionchn_.Get();
}
inline void PerAttri::_internal_set_perdescriptionchn(const std::string& value) {
  
  perdescriptionchn_.Set(value, GetArenaForAllocation());
}
inline std::string* PerAttri::_internal_mutable_perdescriptionchn() {
  
  return perdescriptionchn_.Mutable(GetArenaForAllocation());
}
inline std::string* PerAttri::release_perdescriptionchn() {
  // @@protoc_insertion_point(field_release:PerAttri.PerDescriptionCHN)
  return perdescriptionchn_.Release();
}
inline void PerAttri::set_allocated_perdescriptionchn(std::string* perdescriptionchn) {
  if (perdescriptionchn != nullptr) {
    
  } else {
    
  }
  perdescriptionchn_.SetAllocated(perdescriptionchn, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (perdescriptionchn_.IsDefault()) {
    perdescriptionchn_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:PerAttri.PerDescriptionCHN)
}

// string PerDescriptionENG = 6;
inline void PerAttri::clear_perdescriptioneng() {
  perdescriptioneng_.ClearToEmpty();
}
inline const std::string& PerAttri::perdescriptioneng() const {
  // @@protoc_insertion_point(field_get:PerAttri.PerDescriptionENG)
  return _internal_perdescriptioneng();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PerAttri::set_perdescriptioneng(ArgT0&& arg0, ArgT... args) {
 
 perdescriptioneng_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:PerAttri.PerDescriptionENG)
}
inline std::string* PerAttri::mutable_perdescriptioneng() {
  std::string* _s = _internal_mutable_perdescriptioneng();
  // @@protoc_insertion_point(field_mutable:PerAttri.PerDescriptionENG)
  return _s;
}
inline const std::string& PerAttri::_internal_perdescriptioneng() const {
  return perdescriptioneng_.Get();
}
inline void PerAttri::_internal_set_perdescriptioneng(const std::string& value) {
  
  perdescriptioneng_.Set(value, GetArenaForAllocation());
}
inline std::string* PerAttri::_internal_mutable_perdescriptioneng() {
  
  return perdescriptioneng_.Mutable(GetArenaForAllocation());
}
inline std::string* PerAttri::release_perdescriptioneng() {
  // @@protoc_insertion_point(field_release:PerAttri.PerDescriptionENG)
  return perdescriptioneng_.Release();
}
inline void PerAttri::set_allocated_perdescriptioneng(std::string* perdescriptioneng) {
  if (perdescriptioneng != nullptr) {
    
  } else {
    
  }
  perdescriptioneng_.SetAllocated(perdescriptioneng, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (perdescriptioneng_.IsDefault()) {
    perdescriptioneng_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:PerAttri.PerDescriptionENG)
}

// .OperandType FieldType = 7;
inline void PerAttri::clear_fieldtype() {
  fieldtype_ = 0;
}
inline ::OperandType PerAttri::_internal_fieldtype() const {
  return static_cast< ::OperandType >(fieldtype_);
}
inline ::OperandType PerAttri::fieldtype() const {
  // @@protoc_insertion_point(field_get:PerAttri.FieldType)
  return _internal_fieldtype();
}
inline void PerAttri::_internal_set_fieldtype(::OperandType value) {
  
  fieldtype_ = value;
}
inline void PerAttri::set_fieldtype(::OperandType value) {
  _internal_set_fieldtype(value);
  // @@protoc_insertion_point(field_set:PerAttri.FieldType)
}

// string FieldUnit = 8;
inline void PerAttri::clear_fieldunit() {
  fieldunit_.ClearToEmpty();
}
inline const std::string& PerAttri::fieldunit() const {
  // @@protoc_insertion_point(field_get:PerAttri.FieldUnit)
  return _internal_fieldunit();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PerAttri::set_fieldunit(ArgT0&& arg0, ArgT... args) {
 
 fieldunit_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:PerAttri.FieldUnit)
}
inline std::string* PerAttri::mutable_fieldunit() {
  std::string* _s = _internal_mutable_fieldunit();
  // @@protoc_insertion_point(field_mutable:PerAttri.FieldUnit)
  return _s;
}
inline const std::string& PerAttri::_internal_fieldunit() const {
  return fieldunit_.Get();
}
inline void PerAttri::_internal_set_fieldunit(const std::string& value) {
  
  fieldunit_.Set(value, GetArenaForAllocation());
}
inline std::string* PerAttri::_internal_mutable_fieldunit() {
  
  return fieldunit_.Mutable(GetArenaForAllocation());
}
inline std::string* PerAttri::release_fieldunit() {
  // @@protoc_insertion_point(field_release:PerAttri.FieldUnit)
  return fieldunit_.Release();
}
inline void PerAttri::set_allocated_fieldunit(std::string* fieldunit) {
  if (fieldunit != nullptr) {
    
  } else {
    
  }
  fieldunit_.SetAllocated(fieldunit, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (fieldunit_.IsDefault()) {
    fieldunit_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:PerAttri.FieldUnit)
}

// .Operator Operator1 = 9;
inline void PerAttri::clear_operator1() {
  operator1_ = 0;
}
inline ::Operator PerAttri::_internal_operator1() const {
  return static_cast< ::Operator >(operator1_);
}
inline ::Operator PerAttri::operator1() const {
  // @@protoc_insertion_point(field_get:PerAttri.Operator1)
  return _internal_operator1();
}
inline void PerAttri::_internal_set_operator1(::Operator value) {
  
  operator1_ = value;
}
inline void PerAttri::set_operator1(::Operator value) {
  _internal_set_operator1(value);
  // @@protoc_insertion_point(field_set:PerAttri.Operator1)
}

// string Operand1 = 10;
inline void PerAttri::clear_operand1() {
  operand1_.ClearToEmpty();
}
inline const std::string& PerAttri::operand1() const {
  // @@protoc_insertion_point(field_get:PerAttri.Operand1)
  return _internal_operand1();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PerAttri::set_operand1(ArgT0&& arg0, ArgT... args) {
 
 operand1_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:PerAttri.Operand1)
}
inline std::string* PerAttri::mutable_operand1() {
  std::string* _s = _internal_mutable_operand1();
  // @@protoc_insertion_point(field_mutable:PerAttri.Operand1)
  return _s;
}
inline const std::string& PerAttri::_internal_operand1() const {
  return operand1_.Get();
}
inline void PerAttri::_internal_set_operand1(const std::string& value) {
  
  operand1_.Set(value, GetArenaForAllocation());
}
inline std::string* PerAttri::_internal_mutable_operand1() {
  
  return operand1_.Mutable(GetArenaForAllocation());
}
inline std::string* PerAttri::release_operand1() {
  // @@protoc_insertion_point(field_release:PerAttri.Operand1)
  return operand1_.Release();
}
inline void PerAttri::set_allocated_operand1(std::string* operand1) {
  if (operand1 != nullptr) {
    
  } else {
    
  }
  operand1_.SetAllocated(operand1, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (operand1_.IsDefault()) {
    operand1_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:PerAttri.Operand1)
}

// .RelationOperator Relation = 11;
inline void PerAttri::clear_relation() {
  relation_ = 0;
}
inline ::RelationOperator PerAttri::_internal_relation() const {
  return static_cast< ::RelationOperator >(relation_);
}
inline ::RelationOperator PerAttri::relation() const {
  // @@protoc_insertion_point(field_get:PerAttri.Relation)
  return _internal_relation();
}
inline void PerAttri::_internal_set_relation(::RelationOperator value) {
  
  relation_ = value;
}
inline void PerAttri::set_relation(::RelationOperator value) {
  _internal_set_relation(value);
  // @@protoc_insertion_point(field_set:PerAttri.Relation)
}

// .Operator Operator2 = 12;
inline void PerAttri::clear_operator2() {
  operator2_ = 0;
}
inline ::Operator PerAttri::_internal_operator2() const {
  return static_cast< ::Operator >(operator2_);
}
inline ::Operator PerAttri::operator2() const {
  // @@protoc_insertion_point(field_get:PerAttri.Operator2)
  return _internal_operator2();
}
inline void PerAttri::_internal_set_operator2(::Operator value) {
  
  operator2_ = value;
}
inline void PerAttri::set_operator2(::Operator value) {
  _internal_set_operator2(value);
  // @@protoc_insertion_point(field_set:PerAttri.Operator2)
}

// string Operand2 = 13;
inline void PerAttri::clear_operand2() {
  operand2_.ClearToEmpty();
}
inline const std::string& PerAttri::operand2() const {
  // @@protoc_insertion_point(field_get:PerAttri.Operand2)
  return _internal_operand2();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PerAttri::set_operand2(ArgT0&& arg0, ArgT... args) {
 
 operand2_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:PerAttri.Operand2)
}
inline std::string* PerAttri::mutable_operand2() {
  std::string* _s = _internal_mutable_operand2();
  // @@protoc_insertion_point(field_mutable:PerAttri.Operand2)
  return _s;
}
inline const std::string& PerAttri::_internal_operand2() const {
  return operand2_.Get();
}
inline void PerAttri::_internal_set_operand2(const std::string& value) {
  
  operand2_.Set(value, GetArenaForAllocation());
}
inline std::string* PerAttri::_internal_mutable_operand2() {
  
  return operand2_.Mutable(GetArenaForAllocation());
}
inline std::string* PerAttri::release_operand2() {
  // @@protoc_insertion_point(field_release:PerAttri.Operand2)
  return operand2_.Release();
}
inline void PerAttri::set_allocated_operand2(std::string* operand2) {
  if (operand2 != nullptr) {
    
  } else {
    
  }
  operand2_.SetAllocated(operand2, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (operand2_.IsDefault()) {
    operand2_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:PerAttri.Operand2)
}

// uint32 IsMon = 14;
inline void PerAttri::clear_ismon() {
  ismon_ = 0u;
}
inline uint32_t PerAttri::_internal_ismon() const {
  return ismon_;
}
inline uint32_t PerAttri::ismon() const {
  // @@protoc_insertion_point(field_get:PerAttri.IsMon)
  return _internal_ismon();
}
inline void PerAttri::_internal_set_ismon(uint32_t value) {
  
  ismon_ = value;
}
inline void PerAttri::set_ismon(uint32_t value) {
  _internal_set_ismon(value);
  // @@protoc_insertion_point(field_set:PerAttri.IsMon)
}

// .Level PerAlarmLevel = 15;
inline void PerAttri::clear_peralarmlevel() {
  peralarmlevel_ = 0;
}
inline ::Level PerAttri::_internal_peralarmlevel() const {
  return static_cast< ::Level >(peralarmlevel_);
}
inline ::Level PerAttri::peralarmlevel() const {
  // @@protoc_insertion_point(field_get:PerAttri.PerAlarmLevel)
  return _internal_peralarmlevel();
}
inline void PerAttri::_internal_set_peralarmlevel(::Level value) {
  
  peralarmlevel_ = value;
}
inline void PerAttri::set_peralarmlevel(::Level value) {
  _internal_set_peralarmlevel(value);
  // @@protoc_insertion_point(field_set:PerAttri.PerAlarmLevel)
}

// string AlarmDesCHN = 16;
inline void PerAttri::clear_alarmdeschn() {
  alarmdeschn_.ClearToEmpty();
}
inline const std::string& PerAttri::alarmdeschn() const {
  // @@protoc_insertion_point(field_get:PerAttri.AlarmDesCHN)
  return _internal_alarmdeschn();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PerAttri::set_alarmdeschn(ArgT0&& arg0, ArgT... args) {
 
 alarmdeschn_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:PerAttri.AlarmDesCHN)
}
inline std::string* PerAttri::mutable_alarmdeschn() {
  std::string* _s = _internal_mutable_alarmdeschn();
  // @@protoc_insertion_point(field_mutable:PerAttri.AlarmDesCHN)
  return _s;
}
inline const std::string& PerAttri::_internal_alarmdeschn() const {
  return alarmdeschn_.Get();
}
inline void PerAttri::_internal_set_alarmdeschn(const std::string& value) {
  
  alarmdeschn_.Set(value, GetArenaForAllocation());
}
inline std::string* PerAttri::_internal_mutable_alarmdeschn() {
  
  return alarmdeschn_.Mutable(GetArenaForAllocation());
}
inline std::string* PerAttri::release_alarmdeschn() {
  // @@protoc_insertion_point(field_release:PerAttri.AlarmDesCHN)
  return alarmdeschn_.Release();
}
inline void PerAttri::set_allocated_alarmdeschn(std::string* alarmdeschn) {
  if (alarmdeschn != nullptr) {
    
  } else {
    
  }
  alarmdeschn_.SetAllocated(alarmdeschn, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (alarmdeschn_.IsDefault()) {
    alarmdeschn_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:PerAttri.AlarmDesCHN)
}

// string AlarmDesENG = 17;
inline void PerAttri::clear_alarmdeseng() {
  alarmdeseng_.ClearToEmpty();
}
inline const std::string& PerAttri::alarmdeseng() const {
  // @@protoc_insertion_point(field_get:PerAttri.AlarmDesENG)
  return _internal_alarmdeseng();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PerAttri::set_alarmdeseng(ArgT0&& arg0, ArgT... args) {
 
 alarmdeseng_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:PerAttri.AlarmDesENG)
}
inline std::string* PerAttri::mutable_alarmdeseng() {
  std::string* _s = _internal_mutable_alarmdeseng();
  // @@protoc_insertion_point(field_mutable:PerAttri.AlarmDesENG)
  return _s;
}
inline const std::string& PerAttri::_internal_alarmdeseng() const {
  return alarmdeseng_.Get();
}
inline void PerAttri::_internal_set_alarmdeseng(const std::string& value) {
  
  alarmdeseng_.Set(value, GetArenaForAllocation());
}
inline std::string* PerAttri::_internal_mutable_alarmdeseng() {
  
  return alarmdeseng_.Mutable(GetArenaForAllocation());
}
inline std::string* PerAttri::release_alarmdeseng() {
  // @@protoc_insertion_point(field_release:PerAttri.AlarmDesENG)
  return alarmdeseng_.Release();
}
inline void PerAttri::set_allocated_alarmdeseng(std::string* alarmdeseng) {
  if (alarmdeseng != nullptr) {
    
  } else {
    
  }
  alarmdeseng_.SetAllocated(alarmdeseng, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (alarmdeseng_.IsDefault()) {
    alarmdeseng_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:PerAttri.AlarmDesENG)
}

// .google.protobuf.Timestamp CreateTime = 18;
inline bool PerAttri::_internal_has_createtime() const {
  return this != internal_default_instance() && createtime_ != nullptr;
}
inline bool PerAttri::has_createtime() const {
  return _internal_has_createtime();
}
inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& PerAttri::_internal_createtime() const {
  const ::PROTOBUF_NAMESPACE_ID::Timestamp* p = createtime_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Timestamp&>(
      ::PROTOBUF_NAMESPACE_ID::_Timestamp_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& PerAttri::createtime() const {
  // @@protoc_insertion_point(field_get:PerAttri.CreateTime)
  return _internal_createtime();
}
inline void PerAttri::unsafe_arena_set_allocated_createtime(
    ::PROTOBUF_NAMESPACE_ID::Timestamp* createtime) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(createtime_);
  }
  createtime_ = createtime;
  if (createtime) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PerAttri.CreateTime)
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* PerAttri::release_createtime() {
  
  ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = createtime_;
  createtime_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* PerAttri::unsafe_arena_release_createtime() {
  // @@protoc_insertion_point(field_release:PerAttri.CreateTime)
  
  ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = createtime_;
  createtime_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* PerAttri::_internal_mutable_createtime() {
  
  if (createtime_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Timestamp>(GetArenaForAllocation());
    createtime_ = p;
  }
  return createtime_;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* PerAttri::mutable_createtime() {
  ::PROTOBUF_NAMESPACE_ID::Timestamp* _msg = _internal_mutable_createtime();
  // @@protoc_insertion_point(field_mutable:PerAttri.CreateTime)
  return _msg;
}
inline void PerAttri::set_allocated_createtime(::PROTOBUF_NAMESPACE_ID::Timestamp* createtime) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(createtime_);
  }
  if (createtime) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(createtime));
    if (message_arena != submessage_arena) {
      createtime = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, createtime, submessage_arena);
    }
    
  } else {
    
  }
  createtime_ = createtime;
  // @@protoc_insertion_point(field_set_allocated:PerAttri.CreateTime)
}

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

// CurrAlarm

// uint32 Id = 1;
inline void CurrAlarm::clear_id() {
  id_ = 0u;
}
inline uint32_t CurrAlarm::_internal_id() const {
  return id_;
}
inline uint32_t CurrAlarm::id() const {
  // @@protoc_insertion_point(field_get:CurrAlarm.Id)
  return _internal_id();
}
inline void CurrAlarm::_internal_set_id(uint32_t value) {
  
  id_ = value;
}
inline void CurrAlarm::set_id(uint32_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:CurrAlarm.Id)
}

// uint32 AlarmID = 2;
inline void CurrAlarm::clear_alarmid() {
  alarmid_ = 0u;
}
inline uint32_t CurrAlarm::_internal_alarmid() const {
  return alarmid_;
}
inline uint32_t CurrAlarm::alarmid() const {
  // @@protoc_insertion_point(field_get:CurrAlarm.AlarmID)
  return _internal_alarmid();
}
inline void CurrAlarm::_internal_set_alarmid(uint32_t value) {
  
  alarmid_ = value;
}
inline void CurrAlarm::set_alarmid(uint32_t value) {
  _internal_set_alarmid(value);
  // @@protoc_insertion_point(field_set:CurrAlarm.AlarmID)
}

// uint32 StationID = 3;
inline void CurrAlarm::clear_stationid() {
  stationid_ = 0u;
}
inline uint32_t CurrAlarm::_internal_stationid() const {
  return stationid_;
}
inline uint32_t CurrAlarm::stationid() const {
  // @@protoc_insertion_point(field_get:CurrAlarm.StationID)
  return _internal_stationid();
}
inline void CurrAlarm::_internal_set_stationid(uint32_t value) {
  
  stationid_ = value;
}
inline void CurrAlarm::set_stationid(uint32_t value) {
  _internal_set_stationid(value);
  // @@protoc_insertion_point(field_set:CurrAlarm.StationID)
}

// uint32 DeviceID = 4;
inline void CurrAlarm::clear_deviceid() {
  deviceid_ = 0u;
}
inline uint32_t CurrAlarm::_internal_deviceid() const {
  return deviceid_;
}
inline uint32_t CurrAlarm::deviceid() const {
  // @@protoc_insertion_point(field_get:CurrAlarm.DeviceID)
  return _internal_deviceid();
}
inline void CurrAlarm::_internal_set_deviceid(uint32_t value) {
  
  deviceid_ = value;
}
inline void CurrAlarm::set_deviceid(uint32_t value) {
  _internal_set_deviceid(value);
  // @@protoc_insertion_point(field_set:CurrAlarm.DeviceID)
}

// .Level AlarmLevel = 5;
inline void CurrAlarm::clear_alarmlevel() {
  alarmlevel_ = 0;
}
inline ::Level CurrAlarm::_internal_alarmlevel() const {
  return static_cast< ::Level >(alarmlevel_);
}
inline ::Level CurrAlarm::alarmlevel() const {
  // @@protoc_insertion_point(field_get:CurrAlarm.AlarmLevel)
  return _internal_alarmlevel();
}
inline void CurrAlarm::_internal_set_alarmlevel(::Level value) {
  
  alarmlevel_ = value;
}
inline void CurrAlarm::set_alarmlevel(::Level value) {
  _internal_set_alarmlevel(value);
  // @@protoc_insertion_point(field_set:CurrAlarm.AlarmLevel)
}

// string AlarmDescriptionCHN = 6;
inline void CurrAlarm::clear_alarmdescriptionchn() {
  alarmdescriptionchn_.ClearToEmpty();
}
inline const std::string& CurrAlarm::alarmdescriptionchn() const {
  // @@protoc_insertion_point(field_get:CurrAlarm.AlarmDescriptionCHN)
  return _internal_alarmdescriptionchn();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CurrAlarm::set_alarmdescriptionchn(ArgT0&& arg0, ArgT... args) {
 
 alarmdescriptionchn_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CurrAlarm.AlarmDescriptionCHN)
}
inline std::string* CurrAlarm::mutable_alarmdescriptionchn() {
  std::string* _s = _internal_mutable_alarmdescriptionchn();
  // @@protoc_insertion_point(field_mutable:CurrAlarm.AlarmDescriptionCHN)
  return _s;
}
inline const std::string& CurrAlarm::_internal_alarmdescriptionchn() const {
  return alarmdescriptionchn_.Get();
}
inline void CurrAlarm::_internal_set_alarmdescriptionchn(const std::string& value) {
  
  alarmdescriptionchn_.Set(value, GetArenaForAllocation());
}
inline std::string* CurrAlarm::_internal_mutable_alarmdescriptionchn() {
  
  return alarmdescriptionchn_.Mutable(GetArenaForAllocation());
}
inline std::string* CurrAlarm::release_alarmdescriptionchn() {
  // @@protoc_insertion_point(field_release:CurrAlarm.AlarmDescriptionCHN)
  return alarmdescriptionchn_.Release();
}
inline void CurrAlarm::set_allocated_alarmdescriptionchn(std::string* alarmdescriptionchn) {
  if (alarmdescriptionchn != nullptr) {
    
  } else {
    
  }
  alarmdescriptionchn_.SetAllocated(alarmdescriptionchn, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (alarmdescriptionchn_.IsDefault()) {
    alarmdescriptionchn_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CurrAlarm.AlarmDescriptionCHN)
}

// string AlarmDescriptionENG = 7;
inline void CurrAlarm::clear_alarmdescriptioneng() {
  alarmdescriptioneng_.ClearToEmpty();
}
inline const std::string& CurrAlarm::alarmdescriptioneng() const {
  // @@protoc_insertion_point(field_get:CurrAlarm.AlarmDescriptionENG)
  return _internal_alarmdescriptioneng();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CurrAlarm::set_alarmdescriptioneng(ArgT0&& arg0, ArgT... args) {
 
 alarmdescriptioneng_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CurrAlarm.AlarmDescriptionENG)
}
inline std::string* CurrAlarm::mutable_alarmdescriptioneng() {
  std::string* _s = _internal_mutable_alarmdescriptioneng();
  // @@protoc_insertion_point(field_mutable:CurrAlarm.AlarmDescriptionENG)
  return _s;
}
inline const std::string& CurrAlarm::_internal_alarmdescriptioneng() const {
  return alarmdescriptioneng_.Get();
}
inline void CurrAlarm::_internal_set_alarmdescriptioneng(const std::string& value) {
  
  alarmdescriptioneng_.Set(value, GetArenaForAllocation());
}
inline std::string* CurrAlarm::_internal_mutable_alarmdescriptioneng() {
  
  return alarmdescriptioneng_.Mutable(GetArenaForAllocation());
}
inline std::string* CurrAlarm::release_alarmdescriptioneng() {
  // @@protoc_insertion_point(field_release:CurrAlarm.AlarmDescriptionENG)
  return alarmdescriptioneng_.Release();
}
inline void CurrAlarm::set_allocated_alarmdescriptioneng(std::string* alarmdescriptioneng) {
  if (alarmdescriptioneng != nullptr) {
    
  } else {
    
  }
  alarmdescriptioneng_.SetAllocated(alarmdescriptioneng, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (alarmdescriptioneng_.IsDefault()) {
    alarmdescriptioneng_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CurrAlarm.AlarmDescriptionENG)
}

// .google.protobuf.Timestamp ReportTime = 8;
inline bool CurrAlarm::_internal_has_reporttime() const {
  return this != internal_default_instance() && reporttime_ != nullptr;
}
inline bool CurrAlarm::has_reporttime() const {
  return _internal_has_reporttime();
}
inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& CurrAlarm::_internal_reporttime() const {
  const ::PROTOBUF_NAMESPACE_ID::Timestamp* p = reporttime_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Timestamp&>(
      ::PROTOBUF_NAMESPACE_ID::_Timestamp_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& CurrAlarm::reporttime() const {
  // @@protoc_insertion_point(field_get:CurrAlarm.ReportTime)
  return _internal_reporttime();
}
inline void CurrAlarm::unsafe_arena_set_allocated_reporttime(
    ::PROTOBUF_NAMESPACE_ID::Timestamp* reporttime) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(reporttime_);
  }
  reporttime_ = reporttime;
  if (reporttime) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CurrAlarm.ReportTime)
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* CurrAlarm::release_reporttime() {
  
  ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = reporttime_;
  reporttime_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* CurrAlarm::unsafe_arena_release_reporttime() {
  // @@protoc_insertion_point(field_release:CurrAlarm.ReportTime)
  
  ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = reporttime_;
  reporttime_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* CurrAlarm::_internal_mutable_reporttime() {
  
  if (reporttime_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Timestamp>(GetArenaForAllocation());
    reporttime_ = p;
  }
  return reporttime_;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* CurrAlarm::mutable_reporttime() {
  ::PROTOBUF_NAMESPACE_ID::Timestamp* _msg = _internal_mutable_reporttime();
  // @@protoc_insertion_point(field_mutable:CurrAlarm.ReportTime)
  return _msg;
}
inline void CurrAlarm::set_allocated_reporttime(::PROTOBUF_NAMESPACE_ID::Timestamp* reporttime) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(reporttime_);
  }
  if (reporttime) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(reporttime));
    if (message_arena != submessage_arena) {
      reporttime = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, reporttime, submessage_arena);
    }
    
  } else {
    
  }
  reporttime_ = reporttime;
  // @@protoc_insertion_point(field_set_allocated:CurrAlarm.ReportTime)
}

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

// HisAlarm

// uint32 Id = 1;
inline void HisAlarm::clear_id() {
  id_ = 0u;
}
inline uint32_t HisAlarm::_internal_id() const {
  return id_;
}
inline uint32_t HisAlarm::id() const {
  // @@protoc_insertion_point(field_get:HisAlarm.Id)
  return _internal_id();
}
inline void HisAlarm::_internal_set_id(uint32_t value) {
  
  id_ = value;
}
inline void HisAlarm::set_id(uint32_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:HisAlarm.Id)
}

// uint32 AlarmID = 2;
inline void HisAlarm::clear_alarmid() {
  alarmid_ = 0u;
}
inline uint32_t HisAlarm::_internal_alarmid() const {
  return alarmid_;
}
inline uint32_t HisAlarm::alarmid() const {
  // @@protoc_insertion_point(field_get:HisAlarm.AlarmID)
  return _internal_alarmid();
}
inline void HisAlarm::_internal_set_alarmid(uint32_t value) {
  
  alarmid_ = value;
}
inline void HisAlarm::set_alarmid(uint32_t value) {
  _internal_set_alarmid(value);
  // @@protoc_insertion_point(field_set:HisAlarm.AlarmID)
}

// uint32 StationID = 3;
inline void HisAlarm::clear_stationid() {
  stationid_ = 0u;
}
inline uint32_t HisAlarm::_internal_stationid() const {
  return stationid_;
}
inline uint32_t HisAlarm::stationid() const {
  // @@protoc_insertion_point(field_get:HisAlarm.StationID)
  return _internal_stationid();
}
inline void HisAlarm::_internal_set_stationid(uint32_t value) {
  
  stationid_ = value;
}
inline void HisAlarm::set_stationid(uint32_t value) {
  _internal_set_stationid(value);
  // @@protoc_insertion_point(field_set:HisAlarm.StationID)
}

// uint32 DeviceID = 4;
inline void HisAlarm::clear_deviceid() {
  deviceid_ = 0u;
}
inline uint32_t HisAlarm::_internal_deviceid() const {
  return deviceid_;
}
inline uint32_t HisAlarm::deviceid() const {
  // @@protoc_insertion_point(field_get:HisAlarm.DeviceID)
  return _internal_deviceid();
}
inline void HisAlarm::_internal_set_deviceid(uint32_t value) {
  
  deviceid_ = value;
}
inline void HisAlarm::set_deviceid(uint32_t value) {
  _internal_set_deviceid(value);
  // @@protoc_insertion_point(field_set:HisAlarm.DeviceID)
}

// .Level AlarmLevel = 5;
inline void HisAlarm::clear_alarmlevel() {
  alarmlevel_ = 0;
}
inline ::Level HisAlarm::_internal_alarmlevel() const {
  return static_cast< ::Level >(alarmlevel_);
}
inline ::Level HisAlarm::alarmlevel() const {
  // @@protoc_insertion_point(field_get:HisAlarm.AlarmLevel)
  return _internal_alarmlevel();
}
inline void HisAlarm::_internal_set_alarmlevel(::Level value) {
  
  alarmlevel_ = value;
}
inline void HisAlarm::set_alarmlevel(::Level value) {
  _internal_set_alarmlevel(value);
  // @@protoc_insertion_point(field_set:HisAlarm.AlarmLevel)
}

// string AlarmDescriptionCHN = 6;
inline void HisAlarm::clear_alarmdescriptionchn() {
  alarmdescriptionchn_.ClearToEmpty();
}
inline const std::string& HisAlarm::alarmdescriptionchn() const {
  // @@protoc_insertion_point(field_get:HisAlarm.AlarmDescriptionCHN)
  return _internal_alarmdescriptionchn();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HisAlarm::set_alarmdescriptionchn(ArgT0&& arg0, ArgT... args) {
 
 alarmdescriptionchn_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:HisAlarm.AlarmDescriptionCHN)
}
inline std::string* HisAlarm::mutable_alarmdescriptionchn() {
  std::string* _s = _internal_mutable_alarmdescriptionchn();
  // @@protoc_insertion_point(field_mutable:HisAlarm.AlarmDescriptionCHN)
  return _s;
}
inline const std::string& HisAlarm::_internal_alarmdescriptionchn() const {
  return alarmdescriptionchn_.Get();
}
inline void HisAlarm::_internal_set_alarmdescriptionchn(const std::string& value) {
  
  alarmdescriptionchn_.Set(value, GetArenaForAllocation());
}
inline std::string* HisAlarm::_internal_mutable_alarmdescriptionchn() {
  
  return alarmdescriptionchn_.Mutable(GetArenaForAllocation());
}
inline std::string* HisAlarm::release_alarmdescriptionchn() {
  // @@protoc_insertion_point(field_release:HisAlarm.AlarmDescriptionCHN)
  return alarmdescriptionchn_.Release();
}
inline void HisAlarm::set_allocated_alarmdescriptionchn(std::string* alarmdescriptionchn) {
  if (alarmdescriptionchn != nullptr) {
    
  } else {
    
  }
  alarmdescriptionchn_.SetAllocated(alarmdescriptionchn, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (alarmdescriptionchn_.IsDefault()) {
    alarmdescriptionchn_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:HisAlarm.AlarmDescriptionCHN)
}

// string AlarmDescriptionENG = 7;
inline void HisAlarm::clear_alarmdescriptioneng() {
  alarmdescriptioneng_.ClearToEmpty();
}
inline const std::string& HisAlarm::alarmdescriptioneng() const {
  // @@protoc_insertion_point(field_get:HisAlarm.AlarmDescriptionENG)
  return _internal_alarmdescriptioneng();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HisAlarm::set_alarmdescriptioneng(ArgT0&& arg0, ArgT... args) {
 
 alarmdescriptioneng_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:HisAlarm.AlarmDescriptionENG)
}
inline std::string* HisAlarm::mutable_alarmdescriptioneng() {
  std::string* _s = _internal_mutable_alarmdescriptioneng();
  // @@protoc_insertion_point(field_mutable:HisAlarm.AlarmDescriptionENG)
  return _s;
}
inline const std::string& HisAlarm::_internal_alarmdescriptioneng() const {
  return alarmdescriptioneng_.Get();
}
inline void HisAlarm::_internal_set_alarmdescriptioneng(const std::string& value) {
  
  alarmdescriptioneng_.Set(value, GetArenaForAllocation());
}
inline std::string* HisAlarm::_internal_mutable_alarmdescriptioneng() {
  
  return alarmdescriptioneng_.Mutable(GetArenaForAllocation());
}
inline std::string* HisAlarm::release_alarmdescriptioneng() {
  // @@protoc_insertion_point(field_release:HisAlarm.AlarmDescriptionENG)
  return alarmdescriptioneng_.Release();
}
inline void HisAlarm::set_allocated_alarmdescriptioneng(std::string* alarmdescriptioneng) {
  if (alarmdescriptioneng != nullptr) {
    
  } else {
    
  }
  alarmdescriptioneng_.SetAllocated(alarmdescriptioneng, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (alarmdescriptioneng_.IsDefault()) {
    alarmdescriptioneng_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:HisAlarm.AlarmDescriptionENG)
}

// .google.protobuf.Timestamp StartTime = 8;
inline bool HisAlarm::_internal_has_starttime() const {
  return this != internal_default_instance() && starttime_ != nullptr;
}
inline bool HisAlarm::has_starttime() const {
  return _internal_has_starttime();
}
inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& HisAlarm::_internal_starttime() const {
  const ::PROTOBUF_NAMESPACE_ID::Timestamp* p = starttime_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Timestamp&>(
      ::PROTOBUF_NAMESPACE_ID::_Timestamp_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& HisAlarm::starttime() const {
  // @@protoc_insertion_point(field_get:HisAlarm.StartTime)
  return _internal_starttime();
}
inline void HisAlarm::unsafe_arena_set_allocated_starttime(
    ::PROTOBUF_NAMESPACE_ID::Timestamp* starttime) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(starttime_);
  }
  starttime_ = starttime;
  if (starttime) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:HisAlarm.StartTime)
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* HisAlarm::release_starttime() {
  
  ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = starttime_;
  starttime_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* HisAlarm::unsafe_arena_release_starttime() {
  // @@protoc_insertion_point(field_release:HisAlarm.StartTime)
  
  ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = starttime_;
  starttime_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* HisAlarm::_internal_mutable_starttime() {
  
  if (starttime_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Timestamp>(GetArenaForAllocation());
    starttime_ = p;
  }
  return starttime_;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* HisAlarm::mutable_starttime() {
  ::PROTOBUF_NAMESPACE_ID::Timestamp* _msg = _internal_mutable_starttime();
  // @@protoc_insertion_point(field_mutable:HisAlarm.StartTime)
  return _msg;
}
inline void HisAlarm::set_allocated_starttime(::PROTOBUF_NAMESPACE_ID::Timestamp* starttime) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(starttime_);
  }
  if (starttime) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(starttime));
    if (message_arena != submessage_arena) {
      starttime = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, starttime, submessage_arena);
    }
    
  } else {
    
  }
  starttime_ = starttime;
  // @@protoc_insertion_point(field_set_allocated:HisAlarm.StartTime)
}

// .google.protobuf.Timestamp EndTime = 9;
inline bool HisAlarm::_internal_has_endtime() const {
  return this != internal_default_instance() && endtime_ != nullptr;
}
inline bool HisAlarm::has_endtime() const {
  return _internal_has_endtime();
}
inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& HisAlarm::_internal_endtime() const {
  const ::PROTOBUF_NAMESPACE_ID::Timestamp* p = endtime_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Timestamp&>(
      ::PROTOBUF_NAMESPACE_ID::_Timestamp_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& HisAlarm::endtime() const {
  // @@protoc_insertion_point(field_get:HisAlarm.EndTime)
  return _internal_endtime();
}
inline void HisAlarm::unsafe_arena_set_allocated_endtime(
    ::PROTOBUF_NAMESPACE_ID::Timestamp* endtime) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(endtime_);
  }
  endtime_ = endtime;
  if (endtime) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:HisAlarm.EndTime)
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* HisAlarm::release_endtime() {
  
  ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = endtime_;
  endtime_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* HisAlarm::unsafe_arena_release_endtime() {
  // @@protoc_insertion_point(field_release:HisAlarm.EndTime)
  
  ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = endtime_;
  endtime_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* HisAlarm::_internal_mutable_endtime() {
  
  if (endtime_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Timestamp>(GetArenaForAllocation());
    endtime_ = p;
  }
  return endtime_;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* HisAlarm::mutable_endtime() {
  ::PROTOBUF_NAMESPACE_ID::Timestamp* _msg = _internal_mutable_endtime();
  // @@protoc_insertion_point(field_mutable:HisAlarm.EndTime)
  return _msg;
}
inline void HisAlarm::set_allocated_endtime(::PROTOBUF_NAMESPACE_ID::Timestamp* endtime) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(endtime_);
  }
  if (endtime) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(endtime));
    if (message_arena != submessage_arena) {
      endtime = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, endtime, submessage_arena);
    }
    
  } else {
    
  }
  endtime_ = endtime;
  // @@protoc_insertion_point(field_set_allocated:HisAlarm.EndTime)
}

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

// SysStatus

// uint32 StationID = 1;
inline void SysStatus::clear_stationid() {
  stationid_ = 0u;
}
inline uint32_t SysStatus::_internal_stationid() const {
  return stationid_;
}
inline uint32_t SysStatus::stationid() const {
  // @@protoc_insertion_point(field_get:SysStatus.StationID)
  return _internal_stationid();
}
inline void SysStatus::_internal_set_stationid(uint32_t value) {
  
  stationid_ = value;
}
inline void SysStatus::set_stationid(uint32_t value) {
  _internal_set_stationid(value);
  // @@protoc_insertion_point(field_set:SysStatus.StationID)
}

// uint32 DeviceID = 2;
inline void SysStatus::clear_deviceid() {
  deviceid_ = 0u;
}
inline uint32_t SysStatus::_internal_deviceid() const {
  return deviceid_;
}
inline uint32_t SysStatus::deviceid() const {
  // @@protoc_insertion_point(field_get:SysStatus.DeviceID)
  return _internal_deviceid();
}
inline void SysStatus::_internal_set_deviceid(uint32_t value) {
  
  deviceid_ = value;
}
inline void SysStatus::set_deviceid(uint32_t value) {
  _internal_set_deviceid(value);
  // @@protoc_insertion_point(field_set:SysStatus.DeviceID)
}

// .Devistatus Status = 3;
inline void SysStatus::clear_status() {
  status_ = 0;
}
inline ::Devistatus SysStatus::_internal_status() const {
  return static_cast< ::Devistatus >(status_);
}
inline ::Devistatus SysStatus::status() const {
  // @@protoc_insertion_point(field_get:SysStatus.Status)
  return _internal_status();
}
inline void SysStatus::_internal_set_status(::Devistatus value) {
  
  status_ = value;
}
inline void SysStatus::set_status(::Devistatus value) {
  _internal_set_status(value);
  // @@protoc_insertion_point(field_set:SysStatus.Status)
}

// .google.protobuf.Timestamp ReportTime = 4;
inline bool SysStatus::_internal_has_reporttime() const {
  return this != internal_default_instance() && reporttime_ != nullptr;
}
inline bool SysStatus::has_reporttime() const {
  return _internal_has_reporttime();
}
inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& SysStatus::_internal_reporttime() const {
  const ::PROTOBUF_NAMESPACE_ID::Timestamp* p = reporttime_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Timestamp&>(
      ::PROTOBUF_NAMESPACE_ID::_Timestamp_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& SysStatus::reporttime() const {
  // @@protoc_insertion_point(field_get:SysStatus.ReportTime)
  return _internal_reporttime();
}
inline void SysStatus::unsafe_arena_set_allocated_reporttime(
    ::PROTOBUF_NAMESPACE_ID::Timestamp* reporttime) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(reporttime_);
  }
  reporttime_ = reporttime;
  if (reporttime) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:SysStatus.ReportTime)
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* SysStatus::release_reporttime() {
  
  ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = reporttime_;
  reporttime_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* SysStatus::unsafe_arena_release_reporttime() {
  // @@protoc_insertion_point(field_release:SysStatus.ReportTime)
  
  ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = reporttime_;
  reporttime_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* SysStatus::_internal_mutable_reporttime() {
  
  if (reporttime_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Timestamp>(GetArenaForAllocation());
    reporttime_ = p;
  }
  return reporttime_;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* SysStatus::mutable_reporttime() {
  ::PROTOBUF_NAMESPACE_ID::Timestamp* _msg = _internal_mutable_reporttime();
  // @@protoc_insertion_point(field_mutable:SysStatus.ReportTime)
  return _msg;
}
inline void SysStatus::set_allocated_reporttime(::PROTOBUF_NAMESPACE_ID::Timestamp* reporttime) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(reporttime_);
  }
  if (reporttime) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(reporttime));
    if (message_arena != submessage_arena) {
      reporttime = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, reporttime, submessage_arena);
    }
    
  } else {
    
  }
  reporttime_ = reporttime;
  // @@protoc_insertion_point(field_set_allocated:SysStatus.ReportTime)
}

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

// Log

// uint32 StationID = 1;
inline void Log::clear_stationid() {
  stationid_ = 0u;
}
inline uint32_t Log::_internal_stationid() const {
  return stationid_;
}
inline uint32_t Log::stationid() const {
  // @@protoc_insertion_point(field_get:Log.StationID)
  return _internal_stationid();
}
inline void Log::_internal_set_stationid(uint32_t value) {
  
  stationid_ = value;
}
inline void Log::set_stationid(uint32_t value) {
  _internal_set_stationid(value);
  // @@protoc_insertion_point(field_set:Log.StationID)
}

// uint32 DeviceID = 2;
inline void Log::clear_deviceid() {
  deviceid_ = 0u;
}
inline uint32_t Log::_internal_deviceid() const {
  return deviceid_;
}
inline uint32_t Log::deviceid() const {
  // @@protoc_insertion_point(field_get:Log.DeviceID)
  return _internal_deviceid();
}
inline void Log::_internal_set_deviceid(uint32_t value) {
  
  deviceid_ = value;
}
inline void Log::set_deviceid(uint32_t value) {
  _internal_set_deviceid(value);
  // @@protoc_insertion_point(field_set:Log.DeviceID)
}

// .LogLevel Loglevel = 3;
inline void Log::clear_loglevel() {
  loglevel_ = 0;
}
inline ::LogLevel Log::_internal_loglevel() const {
  return static_cast< ::LogLevel >(loglevel_);
}
inline ::LogLevel Log::loglevel() const {
  // @@protoc_insertion_point(field_get:Log.Loglevel)
  return _internal_loglevel();
}
inline void Log::_internal_set_loglevel(::LogLevel value) {
  
  loglevel_ = value;
}
inline void Log::set_loglevel(::LogLevel value) {
  _internal_set_loglevel(value);
  // @@protoc_insertion_point(field_set:Log.Loglevel)
}

// string LogInfoCHN = 4;
inline void Log::clear_loginfochn() {
  loginfochn_.ClearToEmpty();
}
inline const std::string& Log::loginfochn() const {
  // @@protoc_insertion_point(field_get:Log.LogInfoCHN)
  return _internal_loginfochn();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Log::set_loginfochn(ArgT0&& arg0, ArgT... args) {
 
 loginfochn_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Log.LogInfoCHN)
}
inline std::string* Log::mutable_loginfochn() {
  std::string* _s = _internal_mutable_loginfochn();
  // @@protoc_insertion_point(field_mutable:Log.LogInfoCHN)
  return _s;
}
inline const std::string& Log::_internal_loginfochn() const {
  return loginfochn_.Get();
}
inline void Log::_internal_set_loginfochn(const std::string& value) {
  
  loginfochn_.Set(value, GetArenaForAllocation());
}
inline std::string* Log::_internal_mutable_loginfochn() {
  
  return loginfochn_.Mutable(GetArenaForAllocation());
}
inline std::string* Log::release_loginfochn() {
  // @@protoc_insertion_point(field_release:Log.LogInfoCHN)
  return loginfochn_.Release();
}
inline void Log::set_allocated_loginfochn(std::string* loginfochn) {
  if (loginfochn != nullptr) {
    
  } else {
    
  }
  loginfochn_.SetAllocated(loginfochn, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (loginfochn_.IsDefault()) {
    loginfochn_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Log.LogInfoCHN)
}

// string LogInfoENG = 5;
inline void Log::clear_loginfoeng() {
  loginfoeng_.ClearToEmpty();
}
inline const std::string& Log::loginfoeng() const {
  // @@protoc_insertion_point(field_get:Log.LogInfoENG)
  return _internal_loginfoeng();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Log::set_loginfoeng(ArgT0&& arg0, ArgT... args) {
 
 loginfoeng_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Log.LogInfoENG)
}
inline std::string* Log::mutable_loginfoeng() {
  std::string* _s = _internal_mutable_loginfoeng();
  // @@protoc_insertion_point(field_mutable:Log.LogInfoENG)
  return _s;
}
inline const std::string& Log::_internal_loginfoeng() const {
  return loginfoeng_.Get();
}
inline void Log::_internal_set_loginfoeng(const std::string& value) {
  
  loginfoeng_.Set(value, GetArenaForAllocation());
}
inline std::string* Log::_internal_mutable_loginfoeng() {
  
  return loginfoeng_.Mutable(GetArenaForAllocation());
}
inline std::string* Log::release_loginfoeng() {
  // @@protoc_insertion_point(field_release:Log.LogInfoENG)
  return loginfoeng_.Release();
}
inline void Log::set_allocated_loginfoeng(std::string* loginfoeng) {
  if (loginfoeng != nullptr) {
    
  } else {
    
  }
  loginfoeng_.SetAllocated(loginfoeng, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (loginfoeng_.IsDefault()) {
    loginfoeng_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Log.LogInfoENG)
}

// string Manipunator = 6;
inline void Log::clear_manipunator() {
  manipunator_.ClearToEmpty();
}
inline const std::string& Log::manipunator() const {
  // @@protoc_insertion_point(field_get:Log.Manipunator)
  return _internal_manipunator();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Log::set_manipunator(ArgT0&& arg0, ArgT... args) {
 
 manipunator_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Log.Manipunator)
}
inline std::string* Log::mutable_manipunator() {
  std::string* _s = _internal_mutable_manipunator();
  // @@protoc_insertion_point(field_mutable:Log.Manipunator)
  return _s;
}
inline const std::string& Log::_internal_manipunator() const {
  return manipunator_.Get();
}
inline void Log::_internal_set_manipunator(const std::string& value) {
  
  manipunator_.Set(value, GetArenaForAllocation());
}
inline std::string* Log::_internal_mutable_manipunator() {
  
  return manipunator_.Mutable(GetArenaForAllocation());
}
inline std::string* Log::release_manipunator() {
  // @@protoc_insertion_point(field_release:Log.Manipunator)
  return manipunator_.Release();
}
inline void Log::set_allocated_manipunator(std::string* manipunator) {
  if (manipunator != nullptr) {
    
  } else {
    
  }
  manipunator_.SetAllocated(manipunator, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (manipunator_.IsDefault()) {
    manipunator_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Log.Manipunator)
}

// .google.protobuf.Timestamp ReportTime = 7;
inline bool Log::_internal_has_reporttime() const {
  return this != internal_default_instance() && reporttime_ != nullptr;
}
inline bool Log::has_reporttime() const {
  return _internal_has_reporttime();
}
inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& Log::_internal_reporttime() const {
  const ::PROTOBUF_NAMESPACE_ID::Timestamp* p = reporttime_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Timestamp&>(
      ::PROTOBUF_NAMESPACE_ID::_Timestamp_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& Log::reporttime() const {
  // @@protoc_insertion_point(field_get:Log.ReportTime)
  return _internal_reporttime();
}
inline void Log::unsafe_arena_set_allocated_reporttime(
    ::PROTOBUF_NAMESPACE_ID::Timestamp* reporttime) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(reporttime_);
  }
  reporttime_ = reporttime;
  if (reporttime) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Log.ReportTime)
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* Log::release_reporttime() {
  
  ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = reporttime_;
  reporttime_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* Log::unsafe_arena_release_reporttime() {
  // @@protoc_insertion_point(field_release:Log.ReportTime)
  
  ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = reporttime_;
  reporttime_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* Log::_internal_mutable_reporttime() {
  
  if (reporttime_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Timestamp>(GetArenaForAllocation());
    reporttime_ = p;
  }
  return reporttime_;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* Log::mutable_reporttime() {
  ::PROTOBUF_NAMESPACE_ID::Timestamp* _msg = _internal_mutable_reporttime();
  // @@protoc_insertion_point(field_mutable:Log.ReportTime)
  return _msg;
}
inline void Log::set_allocated_reporttime(::PROTOBUF_NAMESPACE_ID::Timestamp* reporttime) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(reporttime_);
  }
  if (reporttime) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(reporttime));
    if (message_arena != submessage_arena) {
      reporttime = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, reporttime, submessage_arena);
    }
    
  } else {
    
  }
  reporttime_ = reporttime;
  // @@protoc_insertion_point(field_set_allocated:Log.ReportTime)
}

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

// PerInfo

// uint32 Id = 1;
inline void PerInfo::clear_id() {
  id_ = 0u;
}
inline uint32_t PerInfo::_internal_id() const {
  return id_;
}
inline uint32_t PerInfo::id() const {
  // @@protoc_insertion_point(field_get:PerInfo.Id)
  return _internal_id();
}
inline void PerInfo::_internal_set_id(uint32_t value) {
  
  id_ = value;
}
inline void PerInfo::set_id(uint32_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:PerInfo.Id)
}

// uint32 PerID = 2;
inline void PerInfo::clear_perid() {
  perid_ = 0u;
}
inline uint32_t PerInfo::_internal_perid() const {
  return perid_;
}
inline uint32_t PerInfo::perid() const {
  // @@protoc_insertion_point(field_get:PerInfo.PerID)
  return _internal_perid();
}
inline void PerInfo::_internal_set_perid(uint32_t value) {
  
  perid_ = value;
}
inline void PerInfo::set_perid(uint32_t value) {
  _internal_set_perid(value);
  // @@protoc_insertion_point(field_set:PerInfo.PerID)
}

// uint32 StationID = 3;
inline void PerInfo::clear_stationid() {
  stationid_ = 0u;
}
inline uint32_t PerInfo::_internal_stationid() const {
  return stationid_;
}
inline uint32_t PerInfo::stationid() const {
  // @@protoc_insertion_point(field_get:PerInfo.StationID)
  return _internal_stationid();
}
inline void PerInfo::_internal_set_stationid(uint32_t value) {
  
  stationid_ = value;
}
inline void PerInfo::set_stationid(uint32_t value) {
  _internal_set_stationid(value);
  // @@protoc_insertion_point(field_set:PerInfo.StationID)
}

// uint32 DeviceID = 4;
inline void PerInfo::clear_deviceid() {
  deviceid_ = 0u;
}
inline uint32_t PerInfo::_internal_deviceid() const {
  return deviceid_;
}
inline uint32_t PerInfo::deviceid() const {
  // @@protoc_insertion_point(field_get:PerInfo.DeviceID)
  return _internal_deviceid();
}
inline void PerInfo::_internal_set_deviceid(uint32_t value) {
  
  deviceid_ = value;
}
inline void PerInfo::set_deviceid(uint32_t value) {
  _internal_set_deviceid(value);
  // @@protoc_insertion_point(field_set:PerInfo.DeviceID)
}

// string DataCatlog = 5;
inline void PerInfo::clear_datacatlog() {
  datacatlog_.ClearToEmpty();
}
inline const std::string& PerInfo::datacatlog() const {
  // @@protoc_insertion_point(field_get:PerInfo.DataCatlog)
  return _internal_datacatlog();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PerInfo::set_datacatlog(ArgT0&& arg0, ArgT... args) {
 
 datacatlog_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:PerInfo.DataCatlog)
}
inline std::string* PerInfo::mutable_datacatlog() {
  std::string* _s = _internal_mutable_datacatlog();
  // @@protoc_insertion_point(field_mutable:PerInfo.DataCatlog)
  return _s;
}
inline const std::string& PerInfo::_internal_datacatlog() const {
  return datacatlog_.Get();
}
inline void PerInfo::_internal_set_datacatlog(const std::string& value) {
  
  datacatlog_.Set(value, GetArenaForAllocation());
}
inline std::string* PerInfo::_internal_mutable_datacatlog() {
  
  return datacatlog_.Mutable(GetArenaForAllocation());
}
inline std::string* PerInfo::release_datacatlog() {
  // @@protoc_insertion_point(field_release:PerInfo.DataCatlog)
  return datacatlog_.Release();
}
inline void PerInfo::set_allocated_datacatlog(std::string* datacatlog) {
  if (datacatlog != nullptr) {
    
  } else {
    
  }
  datacatlog_.SetAllocated(datacatlog, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (datacatlog_.IsDefault()) {
    datacatlog_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:PerInfo.DataCatlog)
}

// string FieldName = 6;
inline void PerInfo::clear_fieldname() {
  fieldname_.ClearToEmpty();
}
inline const std::string& PerInfo::fieldname() const {
  // @@protoc_insertion_point(field_get:PerInfo.FieldName)
  return _internal_fieldname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PerInfo::set_fieldname(ArgT0&& arg0, ArgT... args) {
 
 fieldname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:PerInfo.FieldName)
}
inline std::string* PerInfo::mutable_fieldname() {
  std::string* _s = _internal_mutable_fieldname();
  // @@protoc_insertion_point(field_mutable:PerInfo.FieldName)
  return _s;
}
inline const std::string& PerInfo::_internal_fieldname() const {
  return fieldname_.Get();
}
inline void PerInfo::_internal_set_fieldname(const std::string& value) {
  
  fieldname_.Set(value, GetArenaForAllocation());
}
inline std::string* PerInfo::_internal_mutable_fieldname() {
  
  return fieldname_.Mutable(GetArenaForAllocation());
}
inline std::string* PerInfo::release_fieldname() {
  // @@protoc_insertion_point(field_release:PerInfo.FieldName)
  return fieldname_.Release();
}
inline void PerInfo::set_allocated_fieldname(std::string* fieldname) {
  if (fieldname != nullptr) {
    
  } else {
    
  }
  fieldname_.SetAllocated(fieldname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (fieldname_.IsDefault()) {
    fieldname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:PerInfo.FieldName)
}

// string FieldValue = 7;
inline void PerInfo::clear_fieldvalue() {
  fieldvalue_.ClearToEmpty();
}
inline const std::string& PerInfo::fieldvalue() const {
  // @@protoc_insertion_point(field_get:PerInfo.FieldValue)
  return _internal_fieldvalue();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PerInfo::set_fieldvalue(ArgT0&& arg0, ArgT... args) {
 
 fieldvalue_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:PerInfo.FieldValue)
}
inline std::string* PerInfo::mutable_fieldvalue() {
  std::string* _s = _internal_mutable_fieldvalue();
  // @@protoc_insertion_point(field_mutable:PerInfo.FieldValue)
  return _s;
}
inline const std::string& PerInfo::_internal_fieldvalue() const {
  return fieldvalue_.Get();
}
inline void PerInfo::_internal_set_fieldvalue(const std::string& value) {
  
  fieldvalue_.Set(value, GetArenaForAllocation());
}
inline std::string* PerInfo::_internal_mutable_fieldvalue() {
  
  return fieldvalue_.Mutable(GetArenaForAllocation());
}
inline std::string* PerInfo::release_fieldvalue() {
  // @@protoc_insertion_point(field_release:PerInfo.FieldValue)
  return fieldvalue_.Release();
}
inline void PerInfo::set_allocated_fieldvalue(std::string* fieldvalue) {
  if (fieldvalue != nullptr) {
    
  } else {
    
  }
  fieldvalue_.SetAllocated(fieldvalue, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (fieldvalue_.IsDefault()) {
    fieldvalue_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:PerInfo.FieldValue)
}

// string PerDescriptionCHN = 8;
inline void PerInfo::clear_perdescriptionchn() {
  perdescriptionchn_.ClearToEmpty();
}
inline const std::string& PerInfo::perdescriptionchn() const {
  // @@protoc_insertion_point(field_get:PerInfo.PerDescriptionCHN)
  return _internal_perdescriptionchn();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PerInfo::set_perdescriptionchn(ArgT0&& arg0, ArgT... args) {
 
 perdescriptionchn_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:PerInfo.PerDescriptionCHN)
}
inline std::string* PerInfo::mutable_perdescriptionchn() {
  std::string* _s = _internal_mutable_perdescriptionchn();
  // @@protoc_insertion_point(field_mutable:PerInfo.PerDescriptionCHN)
  return _s;
}
inline const std::string& PerInfo::_internal_perdescriptionchn() const {
  return perdescriptionchn_.Get();
}
inline void PerInfo::_internal_set_perdescriptionchn(const std::string& value) {
  
  perdescriptionchn_.Set(value, GetArenaForAllocation());
}
inline std::string* PerInfo::_internal_mutable_perdescriptionchn() {
  
  return perdescriptionchn_.Mutable(GetArenaForAllocation());
}
inline std::string* PerInfo::release_perdescriptionchn() {
  // @@protoc_insertion_point(field_release:PerInfo.PerDescriptionCHN)
  return perdescriptionchn_.Release();
}
inline void PerInfo::set_allocated_perdescriptionchn(std::string* perdescriptionchn) {
  if (perdescriptionchn != nullptr) {
    
  } else {
    
  }
  perdescriptionchn_.SetAllocated(perdescriptionchn, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (perdescriptionchn_.IsDefault()) {
    perdescriptionchn_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:PerInfo.PerDescriptionCHN)
}

// string PerDescriptionENG = 9;
inline void PerInfo::clear_perdescriptioneng() {
  perdescriptioneng_.ClearToEmpty();
}
inline const std::string& PerInfo::perdescriptioneng() const {
  // @@protoc_insertion_point(field_get:PerInfo.PerDescriptionENG)
  return _internal_perdescriptioneng();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PerInfo::set_perdescriptioneng(ArgT0&& arg0, ArgT... args) {
 
 perdescriptioneng_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:PerInfo.PerDescriptionENG)
}
inline std::string* PerInfo::mutable_perdescriptioneng() {
  std::string* _s = _internal_mutable_perdescriptioneng();
  // @@protoc_insertion_point(field_mutable:PerInfo.PerDescriptionENG)
  return _s;
}
inline const std::string& PerInfo::_internal_perdescriptioneng() const {
  return perdescriptioneng_.Get();
}
inline void PerInfo::_internal_set_perdescriptioneng(const std::string& value) {
  
  perdescriptioneng_.Set(value, GetArenaForAllocation());
}
inline std::string* PerInfo::_internal_mutable_perdescriptioneng() {
  
  return perdescriptioneng_.Mutable(GetArenaForAllocation());
}
inline std::string* PerInfo::release_perdescriptioneng() {
  // @@protoc_insertion_point(field_release:PerInfo.PerDescriptionENG)
  return perdescriptioneng_.Release();
}
inline void PerInfo::set_allocated_perdescriptioneng(std::string* perdescriptioneng) {
  if (perdescriptioneng != nullptr) {
    
  } else {
    
  }
  perdescriptioneng_.SetAllocated(perdescriptioneng, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (perdescriptioneng_.IsDefault()) {
    perdescriptioneng_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:PerInfo.PerDescriptionENG)
}

// .google.protobuf.Timestamp UpdateTime = 10;
inline bool PerInfo::_internal_has_updatetime() const {
  return this != internal_default_instance() && updatetime_ != nullptr;
}
inline bool PerInfo::has_updatetime() const {
  return _internal_has_updatetime();
}
inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& PerInfo::_internal_updatetime() const {
  const ::PROTOBUF_NAMESPACE_ID::Timestamp* p = updatetime_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Timestamp&>(
      ::PROTOBUF_NAMESPACE_ID::_Timestamp_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::Timestamp& PerInfo::updatetime() const {
  // @@protoc_insertion_point(field_get:PerInfo.UpdateTime)
  return _internal_updatetime();
}
inline void PerInfo::unsafe_arena_set_allocated_updatetime(
    ::PROTOBUF_NAMESPACE_ID::Timestamp* updatetime) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(updatetime_);
  }
  updatetime_ = updatetime;
  if (updatetime) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:PerInfo.UpdateTime)
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* PerInfo::release_updatetime() {
  
  ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = updatetime_;
  updatetime_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* PerInfo::unsafe_arena_release_updatetime() {
  // @@protoc_insertion_point(field_release:PerInfo.UpdateTime)
  
  ::PROTOBUF_NAMESPACE_ID::Timestamp* temp = updatetime_;
  updatetime_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* PerInfo::_internal_mutable_updatetime() {
  
  if (updatetime_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Timestamp>(GetArenaForAllocation());
    updatetime_ = p;
  }
  return updatetime_;
}
inline ::PROTOBUF_NAMESPACE_ID::Timestamp* PerInfo::mutable_updatetime() {
  ::PROTOBUF_NAMESPACE_ID::Timestamp* _msg = _internal_mutable_updatetime();
  // @@protoc_insertion_point(field_mutable:PerInfo.UpdateTime)
  return _msg;
}
inline void PerInfo::set_allocated_updatetime(::PROTOBUF_NAMESPACE_ID::Timestamp* updatetime) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(updatetime_);
  }
  if (updatetime) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(updatetime));
    if (message_arena != submessage_arena) {
      updatetime = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, updatetime, submessage_arena);
    }
    
  } else {
    
  }
  updatetime_ = updatetime;
  // @@protoc_insertion_point(field_set_allocated:PerInfo.UpdateTime)
}

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

// PerRequire

// string DataCatlog = 1;
inline void PerRequire::clear_datacatlog() {
  datacatlog_.ClearToEmpty();
}
inline const std::string& PerRequire::datacatlog() const {
  // @@protoc_insertion_point(field_get:PerRequire.DataCatlog)
  return _internal_datacatlog();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PerRequire::set_datacatlog(ArgT0&& arg0, ArgT... args) {
 
 datacatlog_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:PerRequire.DataCatlog)
}
inline std::string* PerRequire::mutable_datacatlog() {
  std::string* _s = _internal_mutable_datacatlog();
  // @@protoc_insertion_point(field_mutable:PerRequire.DataCatlog)
  return _s;
}
inline const std::string& PerRequire::_internal_datacatlog() const {
  return datacatlog_.Get();
}
inline void PerRequire::_internal_set_datacatlog(const std::string& value) {
  
  datacatlog_.Set(value, GetArenaForAllocation());
}
inline std::string* PerRequire::_internal_mutable_datacatlog() {
  
  return datacatlog_.Mutable(GetArenaForAllocation());
}
inline std::string* PerRequire::release_datacatlog() {
  // @@protoc_insertion_point(field_release:PerRequire.DataCatlog)
  return datacatlog_.Release();
}
inline void PerRequire::set_allocated_datacatlog(std::string* datacatlog) {
  if (datacatlog != nullptr) {
    
  } else {
    
  }
  datacatlog_.SetAllocated(datacatlog, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (datacatlog_.IsDefault()) {
    datacatlog_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:PerRequire.DataCatlog)
}

// string FieldName = 2;
inline void PerRequire::clear_fieldname() {
  fieldname_.ClearToEmpty();
}
inline const std::string& PerRequire::fieldname() const {
  // @@protoc_insertion_point(field_get:PerRequire.FieldName)
  return _internal_fieldname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PerRequire::set_fieldname(ArgT0&& arg0, ArgT... args) {
 
 fieldname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:PerRequire.FieldName)
}
inline std::string* PerRequire::mutable_fieldname() {
  std::string* _s = _internal_mutable_fieldname();
  // @@protoc_insertion_point(field_mutable:PerRequire.FieldName)
  return _s;
}
inline const std::string& PerRequire::_internal_fieldname() const {
  return fieldname_.Get();
}
inline void PerRequire::_internal_set_fieldname(const std::string& value) {
  
  fieldname_.Set(value, GetArenaForAllocation());
}
inline std::string* PerRequire::_internal_mutable_fieldname() {
  
  return fieldname_.Mutable(GetArenaForAllocation());
}
inline std::string* PerRequire::release_fieldname() {
  // @@protoc_insertion_point(field_release:PerRequire.FieldName)
  return fieldname_.Release();
}
inline void PerRequire::set_allocated_fieldname(std::string* fieldname) {
  if (fieldname != nullptr) {
    
  } else {
    
  }
  fieldname_.SetAllocated(fieldname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (fieldname_.IsDefault()) {
    fieldname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:PerRequire.FieldName)
}

// uint32 IsMon = 3;
inline void PerRequire::clear_ismon() {
  ismon_ = 0u;
}
inline uint32_t PerRequire::_internal_ismon() const {
  return ismon_;
}
inline uint32_t PerRequire::ismon() const {
  // @@protoc_insertion_point(field_get:PerRequire.IsMon)
  return _internal_ismon();
}
inline void PerRequire::_internal_set_ismon(uint32_t value) {
  
  ismon_ = value;
}
inline void PerRequire::set_ismon(uint32_t value) {
  _internal_set_ismon(value);
  // @@protoc_insertion_point(field_set:PerRequire.IsMon)
}

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)


PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::Level> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Level>() {
  return ::Level_descriptor();
}
template <> struct is_proto_enum< ::LogLevel> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::LogLevel>() {
  return ::LogLevel_descriptor();
}
template <> struct is_proto_enum< ::OperandType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::OperandType>() {
  return ::OperandType_descriptor();
}
template <> struct is_proto_enum< ::Operator> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Operator>() {
  return ::Operator_descriptor();
}
template <> struct is_proto_enum< ::RelationOperator> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::RelationOperator>() {
  return ::RelationOperator_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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