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

#ifndef GOOGLE_PROTOBUF_INCLUDED_sysset_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_sysset_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3017000
#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 3017003 < 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_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_sysset_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_sysset_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[6]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_sysset_2eproto;
namespace protomsg {
class Cluster;
struct ClusterDefaultTypeInternal;
extern ClusterDefaultTypeInternal _Cluster_default_instance_;
class ClusterNode;
struct ClusterNodeDefaultTypeInternal;
extern ClusterNodeDefaultTypeInternal _ClusterNode_default_instance_;
class Gb28181Config;
struct Gb28181ConfigDefaultTypeInternal;
extern Gb28181ConfigDefaultTypeInternal _Gb28181Config_default_instance_;
class LocalConfig;
struct LocalConfigDefaultTypeInternal;
extern LocalConfigDefaultTypeInternal _LocalConfig_default_instance_;
class PollConfig;
struct PollConfigDefaultTypeInternal;
extern PollConfigDefaultTypeInternal _PollConfig_default_instance_;
class ResourceConfig;
struct ResourceConfigDefaultTypeInternal;
extern ResourceConfigDefaultTypeInternal _ResourceConfig_default_instance_;
}  // namespace protomsg
PROTOBUF_NAMESPACE_OPEN
template<> ::protomsg::Cluster* Arena::CreateMaybeMessage<::protomsg::Cluster>(Arena*);
template<> ::protomsg::ClusterNode* Arena::CreateMaybeMessage<::protomsg::ClusterNode>(Arena*);
template<> ::protomsg::Gb28181Config* Arena::CreateMaybeMessage<::protomsg::Gb28181Config>(Arena*);
template<> ::protomsg::LocalConfig* Arena::CreateMaybeMessage<::protomsg::LocalConfig>(Arena*);
template<> ::protomsg::PollConfig* Arena::CreateMaybeMessage<::protomsg::PollConfig>(Arena*);
template<> ::protomsg::ResourceConfig* Arena::CreateMaybeMessage<::protomsg::ResourceConfig>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace protomsg {

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

class LocalConfig final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protomsg.LocalConfig) */ {
 public:
  inline LocalConfig() : LocalConfig(nullptr) {}
  ~LocalConfig() override;
  explicit constexpr LocalConfig(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline LocalConfig& operator=(const LocalConfig& from) {
    CopyFrom(from);
    return *this;
  }
  inline LocalConfig& operator=(LocalConfig&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      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 LocalConfig& default_instance() {
    return *internal_default_instance();
  }
  static inline const LocalConfig* internal_default_instance() {
    return reinterpret_cast<const LocalConfig*>(
               &_LocalConfig_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(LocalConfig& a, LocalConfig& b) {
    a.Swap(&b);
  }
  inline void Swap(LocalConfig* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LocalConfig* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  inline LocalConfig* New() const final {
    return new LocalConfig();
  }

  LocalConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LocalConfig>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LocalConfig& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const LocalConfig& 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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* 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(LocalConfig* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "protomsg.LocalConfig";
  }
  protected:
  explicit LocalConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  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 {
    kServerIdFieldNumber = 1,
    kServerNameFieldNumber = 2,
    kServerIpFieldNumber = 4,
    kAlarmIpFieldNumber = 5,
    kWebPicIpFieldNumber = 7,
    kEsPicIpFieldNumber = 9,
    kReservedFieldNumber = 13,
    kGateWayFieldNumber = 14,
    kNetMaskFieldNumber = 15,
    kServerTypeFieldNumber = 3,
    kAlarmPortFieldNumber = 6,
    kWebPicPortFieldNumber = 8,
    kEsPicPortFieldNumber = 10,
    kCutMaxDurationFieldNumber = 11,
    kCutMinDurationFieldNumber = 12,
    kRealMaxFieldNumber = 16,
    kAlarmThresholdTypeFieldNumber = 17,
    kAlarmThresholdFieldNumber = 18,
  };
  // string server_id = 1;
  void clear_server_id();
  const std::string& server_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_server_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_server_id();
  PROTOBUF_MUST_USE_RESULT std::string* release_server_id();
  void set_allocated_server_id(std::string* server_id);
  private:
  const std::string& _internal_server_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_server_id(const std::string& value);
  std::string* _internal_mutable_server_id();
  public:

  // string server_name = 2;
  void clear_server_name();
  const std::string& server_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_server_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_server_name();
  PROTOBUF_MUST_USE_RESULT std::string* release_server_name();
  void set_allocated_server_name(std::string* server_name);
  private:
  const std::string& _internal_server_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_server_name(const std::string& value);
  std::string* _internal_mutable_server_name();
  public:

  // string server_ip = 4;
  void clear_server_ip();
  const std::string& server_ip() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_server_ip(ArgT0&& arg0, ArgT... args);
  std::string* mutable_server_ip();
  PROTOBUF_MUST_USE_RESULT std::string* release_server_ip();
  void set_allocated_server_ip(std::string* server_ip);
  private:
  const std::string& _internal_server_ip() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_server_ip(const std::string& value);
  std::string* _internal_mutable_server_ip();
  public:

  // string alarm_ip = 5;
  void clear_alarm_ip();
  const std::string& alarm_ip() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_alarm_ip(ArgT0&& arg0, ArgT... args);
  std::string* mutable_alarm_ip();
  PROTOBUF_MUST_USE_RESULT std::string* release_alarm_ip();
  void set_allocated_alarm_ip(std::string* alarm_ip);
  private:
  const std::string& _internal_alarm_ip() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_alarm_ip(const std::string& value);
  std::string* _internal_mutable_alarm_ip();
  public:

  // string web_pic_ip = 7;
  void clear_web_pic_ip();
  const std::string& web_pic_ip() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_web_pic_ip(ArgT0&& arg0, ArgT... args);
  std::string* mutable_web_pic_ip();
  PROTOBUF_MUST_USE_RESULT std::string* release_web_pic_ip();
  void set_allocated_web_pic_ip(std::string* web_pic_ip);
  private:
  const std::string& _internal_web_pic_ip() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_web_pic_ip(const std::string& value);
  std::string* _internal_mutable_web_pic_ip();
  public:

  // string es_pic_ip = 9;
  void clear_es_pic_ip();
  const std::string& es_pic_ip() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_es_pic_ip(ArgT0&& arg0, ArgT... args);
  std::string* mutable_es_pic_ip();
  PROTOBUF_MUST_USE_RESULT std::string* release_es_pic_ip();
  void set_allocated_es_pic_ip(std::string* es_pic_ip);
  private:
  const std::string& _internal_es_pic_ip() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_es_pic_ip(const std::string& value);
  std::string* _internal_mutable_es_pic_ip();
  public:

  // string reserved = 13;
  void clear_reserved();
  const std::string& reserved() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_reserved(ArgT0&& arg0, ArgT... args);
  std::string* mutable_reserved();
  PROTOBUF_MUST_USE_RESULT std::string* release_reserved();
  void set_allocated_reserved(std::string* reserved);
  private:
  const std::string& _internal_reserved() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_reserved(const std::string& value);
  std::string* _internal_mutable_reserved();
  public:

  // string gate_way = 14;
  void clear_gate_way();
  const std::string& gate_way() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_gate_way(ArgT0&& arg0, ArgT... args);
  std::string* mutable_gate_way();
  PROTOBUF_MUST_USE_RESULT std::string* release_gate_way();
  void set_allocated_gate_way(std::string* gate_way);
  private:
  const std::string& _internal_gate_way() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_gate_way(const std::string& value);
  std::string* _internal_mutable_gate_way();
  public:

  // string net_mask = 15;
  void clear_net_mask();
  const std::string& net_mask() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_net_mask(ArgT0&& arg0, ArgT... args);
  std::string* mutable_net_mask();
  PROTOBUF_MUST_USE_RESULT std::string* release_net_mask();
  void set_allocated_net_mask(std::string* net_mask);
  private:
  const std::string& _internal_net_mask() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_net_mask(const std::string& value);
  std::string* _internal_mutable_net_mask();
  public:

  // int32 server_type = 3;
  void clear_server_type();
  ::PROTOBUF_NAMESPACE_ID::int32 server_type() const;
  void set_server_type(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_server_type() const;
  void _internal_set_server_type(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 alarm_port = 6;
  void clear_alarm_port();
  ::PROTOBUF_NAMESPACE_ID::int32 alarm_port() const;
  void set_alarm_port(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_alarm_port() const;
  void _internal_set_alarm_port(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 web_pic_port = 8;
  void clear_web_pic_port();
  ::PROTOBUF_NAMESPACE_ID::int32 web_pic_port() const;
  void set_web_pic_port(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_web_pic_port() const;
  void _internal_set_web_pic_port(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 es_pic_port = 10;
  void clear_es_pic_port();
  ::PROTOBUF_NAMESPACE_ID::int32 es_pic_port() const;
  void set_es_pic_port(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_es_pic_port() const;
  void _internal_set_es_pic_port(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 cut_max_duration = 11;
  void clear_cut_max_duration();
  ::PROTOBUF_NAMESPACE_ID::int32 cut_max_duration() const;
  void set_cut_max_duration(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_cut_max_duration() const;
  void _internal_set_cut_max_duration(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 cut_min_duration = 12;
  void clear_cut_min_duration();
  ::PROTOBUF_NAMESPACE_ID::int32 cut_min_duration() const;
  void set_cut_min_duration(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_cut_min_duration() const;
  void _internal_set_cut_min_duration(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 real_max = 16;
  void clear_real_max();
  ::PROTOBUF_NAMESPACE_ID::int32 real_max() const;
  void set_real_max(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_real_max() const;
  void _internal_set_real_max(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 alarm_threshold_type = 17;
  void clear_alarm_threshold_type();
  ::PROTOBUF_NAMESPACE_ID::int32 alarm_threshold_type() const;
  void set_alarm_threshold_type(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_alarm_threshold_type() const;
  void _internal_set_alarm_threshold_type(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 alarm_threshold = 18;
  void clear_alarm_threshold();
  ::PROTOBUF_NAMESPACE_ID::int32 alarm_threshold() const;
  void set_alarm_threshold(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_alarm_threshold() const;
  void _internal_set_alarm_threshold(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:protomsg.LocalConfig)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr server_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr server_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr server_ip_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr alarm_ip_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr web_pic_ip_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr es_pic_ip_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr reserved_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr gate_way_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr net_mask_;
  ::PROTOBUF_NAMESPACE_ID::int32 server_type_;
  ::PROTOBUF_NAMESPACE_ID::int32 alarm_port_;
  ::PROTOBUF_NAMESPACE_ID::int32 web_pic_port_;
  ::PROTOBUF_NAMESPACE_ID::int32 es_pic_port_;
  ::PROTOBUF_NAMESPACE_ID::int32 cut_max_duration_;
  ::PROTOBUF_NAMESPACE_ID::int32 cut_min_duration_;
  ::PROTOBUF_NAMESPACE_ID::int32 real_max_;
  ::PROTOBUF_NAMESPACE_ID::int32 alarm_threshold_type_;
  ::PROTOBUF_NAMESPACE_ID::int32 alarm_threshold_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_sysset_2eproto;
};
// -------------------------------------------------------------------

class PollConfig final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protomsg.PollConfig) */ {
 public:
  inline PollConfig() : PollConfig(nullptr) {}
  ~PollConfig() override;
  explicit constexpr PollConfig(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline PollConfig& operator=(const PollConfig& from) {
    CopyFrom(from);
    return *this;
  }
  inline PollConfig& operator=(PollConfig&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      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 PollConfig& default_instance() {
    return *internal_default_instance();
  }
  static inline const PollConfig* internal_default_instance() {
    return reinterpret_cast<const PollConfig*>(
               &_PollConfig_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(PollConfig& a, PollConfig& b) {
    a.Swap(&b);
  }
  inline void Swap(PollConfig* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PollConfig* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  inline PollConfig* New() const final {
    return new PollConfig();
  }

  PollConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PollConfig>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PollConfig& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const PollConfig& 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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* 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(PollConfig* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "protomsg.PollConfig";
  }
  protected:
  explicit PollConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  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 {
    kServerIdFieldNumber = 1,
    kPollPeriodFieldNumber = 2,
    kDelayFieldNumber = 3,
    kEnableFieldNumber = 4,
    kPollChannelCountFieldNumber = 5,
  };
  // string server_id = 1;
  void clear_server_id();
  const std::string& server_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_server_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_server_id();
  PROTOBUF_MUST_USE_RESULT std::string* release_server_id();
  void set_allocated_server_id(std::string* server_id);
  private:
  const std::string& _internal_server_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_server_id(const std::string& value);
  std::string* _internal_mutable_server_id();
  public:

  // int32 poll_period = 2;
  void clear_poll_period();
  ::PROTOBUF_NAMESPACE_ID::int32 poll_period() const;
  void set_poll_period(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_poll_period() const;
  void _internal_set_poll_period(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 delay = 3;
  void clear_delay();
  ::PROTOBUF_NAMESPACE_ID::int32 delay() const;
  void set_delay(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_delay() const;
  void _internal_set_delay(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // bool enable = 4;
  void clear_enable();
  bool enable() const;
  void set_enable(bool value);
  private:
  bool _internal_enable() const;
  void _internal_set_enable(bool value);
  public:

  // int32 pollChannelCount = 5;
  void clear_pollchannelcount();
  ::PROTOBUF_NAMESPACE_ID::int32 pollchannelcount() const;
  void set_pollchannelcount(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_pollchannelcount() const;
  void _internal_set_pollchannelcount(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:protomsg.PollConfig)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr server_id_;
  ::PROTOBUF_NAMESPACE_ID::int32 poll_period_;
  ::PROTOBUF_NAMESPACE_ID::int32 delay_;
  bool enable_;
  ::PROTOBUF_NAMESPACE_ID::int32 pollchannelcount_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_sysset_2eproto;
};
// -------------------------------------------------------------------

class Cluster final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protomsg.Cluster) */ {
 public:
  inline Cluster() : Cluster(nullptr) {}
  ~Cluster() override;
  explicit constexpr Cluster(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline Cluster& operator=(const Cluster& from) {
    CopyFrom(from);
    return *this;
  }
  inline Cluster& operator=(Cluster&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      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 Cluster& default_instance() {
    return *internal_default_instance();
  }
  static inline const Cluster* internal_default_instance() {
    return reinterpret_cast<const Cluster*>(
               &_Cluster_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(Cluster& a, Cluster& b) {
    a.Swap(&b);
  }
  inline void Swap(Cluster* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Cluster* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  inline Cluster* New() const final {
    return new Cluster();
  }

  Cluster* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Cluster>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Cluster& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Cluster& 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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* 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(Cluster* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "protomsg.Cluster";
  }
  protected:
  explicit Cluster(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  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 {
    kNodesFieldNumber = 5,
    kClusterIdFieldNumber = 1,
    kClusterNameFieldNumber = 2,
    kPasswordFieldNumber = 3,
    kVirtualIpFieldNumber = 4,
  };
  // repeated .protomsg.ClusterNode nodes = 5;
  int nodes_size() const;
  private:
  int _internal_nodes_size() const;
  public:
  void clear_nodes();
  ::protomsg::ClusterNode* mutable_nodes(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protomsg::ClusterNode >*
      mutable_nodes();
  private:
  const ::protomsg::ClusterNode& _internal_nodes(int index) const;
  ::protomsg::ClusterNode* _internal_add_nodes();
  public:
  const ::protomsg::ClusterNode& nodes(int index) const;
  ::protomsg::ClusterNode* add_nodes();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protomsg::ClusterNode >&
      nodes() const;

  // string cluster_id = 1;
  void clear_cluster_id();
  const std::string& cluster_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_cluster_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_cluster_id();
  PROTOBUF_MUST_USE_RESULT std::string* release_cluster_id();
  void set_allocated_cluster_id(std::string* cluster_id);
  private:
  const std::string& _internal_cluster_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cluster_id(const std::string& value);
  std::string* _internal_mutable_cluster_id();
  public:

  // string cluster_name = 2;
  void clear_cluster_name();
  const std::string& cluster_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_cluster_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_cluster_name();
  PROTOBUF_MUST_USE_RESULT std::string* release_cluster_name();
  void set_allocated_cluster_name(std::string* cluster_name);
  private:
  const std::string& _internal_cluster_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cluster_name(const std::string& value);
  std::string* _internal_mutable_cluster_name();
  public:

  // string password = 3;
  void clear_password();
  const std::string& password() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_password(ArgT0&& arg0, ArgT... args);
  std::string* mutable_password();
  PROTOBUF_MUST_USE_RESULT std::string* release_password();
  void set_allocated_password(std::string* password);
  private:
  const std::string& _internal_password() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_password(const std::string& value);
  std::string* _internal_mutable_password();
  public:

  // string virtual_ip = 4;
  void clear_virtual_ip();
  const std::string& virtual_ip() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_virtual_ip(ArgT0&& arg0, ArgT... args);
  std::string* mutable_virtual_ip();
  PROTOBUF_MUST_USE_RESULT std::string* release_virtual_ip();
  void set_allocated_virtual_ip(std::string* virtual_ip);
  private:
  const std::string& _internal_virtual_ip() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_virtual_ip(const std::string& value);
  std::string* _internal_mutable_virtual_ip();
  public:

  // @@protoc_insertion_point(class_scope:protomsg.Cluster)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protomsg::ClusterNode > nodes_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cluster_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cluster_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr password_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr virtual_ip_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_sysset_2eproto;
};
// -------------------------------------------------------------------

class ClusterNode final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protomsg.ClusterNode) */ {
 public:
  inline ClusterNode() : ClusterNode(nullptr) {}
  ~ClusterNode() override;
  explicit constexpr ClusterNode(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ClusterNode& operator=(const ClusterNode& from) {
    CopyFrom(from);
    return *this;
  }
  inline ClusterNode& operator=(ClusterNode&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      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 ClusterNode& default_instance() {
    return *internal_default_instance();
  }
  static inline const ClusterNode* internal_default_instance() {
    return reinterpret_cast<const ClusterNode*>(
               &_ClusterNode_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(ClusterNode& a, ClusterNode& b) {
    a.Swap(&b);
  }
  inline void Swap(ClusterNode* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ClusterNode* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  inline ClusterNode* New() const final {
    return new ClusterNode();
  }

  ClusterNode* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ClusterNode>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ClusterNode& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ClusterNode& 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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* 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(ClusterNode* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "protomsg.ClusterNode";
  }
  protected:
  explicit ClusterNode(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

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

  enum : int {
    kIdFieldNumber = 1,
    kClusterIdFieldNumber = 2,
    kServerIdFieldNumber = 3,
    kServerNameFieldNumber = 4,
    kNodeIdFieldNumber = 5,
    kNodeIpFieldNumber = 6,
    kCreateTimeFieldNumber = 7,
  };
  // string id = 1;
  void clear_id();
  const std::string& id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_id();
  PROTOBUF_MUST_USE_RESULT std::string* release_id();
  void set_allocated_id(std::string* id);
  private:
  const std::string& _internal_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
  std::string* _internal_mutable_id();
  public:

  // string cluster_id = 2;
  void clear_cluster_id();
  const std::string& cluster_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_cluster_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_cluster_id();
  PROTOBUF_MUST_USE_RESULT std::string* release_cluster_id();
  void set_allocated_cluster_id(std::string* cluster_id);
  private:
  const std::string& _internal_cluster_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cluster_id(const std::string& value);
  std::string* _internal_mutable_cluster_id();
  public:

  // string server_id = 3;
  void clear_server_id();
  const std::string& server_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_server_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_server_id();
  PROTOBUF_MUST_USE_RESULT std::string* release_server_id();
  void set_allocated_server_id(std::string* server_id);
  private:
  const std::string& _internal_server_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_server_id(const std::string& value);
  std::string* _internal_mutable_server_id();
  public:

  // string server_name = 4;
  void clear_server_name();
  const std::string& server_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_server_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_server_name();
  PROTOBUF_MUST_USE_RESULT std::string* release_server_name();
  void set_allocated_server_name(std::string* server_name);
  private:
  const std::string& _internal_server_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_server_name(const std::string& value);
  std::string* _internal_mutable_server_name();
  public:

  // string node_id = 5;
  void clear_node_id();
  const std::string& node_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_node_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_node_id();
  PROTOBUF_MUST_USE_RESULT std::string* release_node_id();
  void set_allocated_node_id(std::string* node_id);
  private:
  const std::string& _internal_node_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_node_id(const std::string& value);
  std::string* _internal_mutable_node_id();
  public:

  // string node_ip = 6;
  void clear_node_ip();
  const std::string& node_ip() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_node_ip(ArgT0&& arg0, ArgT... args);
  std::string* mutable_node_ip();
  PROTOBUF_MUST_USE_RESULT std::string* release_node_ip();
  void set_allocated_node_ip(std::string* node_ip);
  private:
  const std::string& _internal_node_ip() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_node_ip(const std::string& value);
  std::string* _internal_mutable_node_ip();
  public:

  // string create_time = 7;
  void clear_create_time();
  const std::string& create_time() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_create_time(ArgT0&& arg0, ArgT... args);
  std::string* mutable_create_time();
  PROTOBUF_MUST_USE_RESULT std::string* release_create_time();
  void set_allocated_create_time(std::string* create_time);
  private:
  const std::string& _internal_create_time() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_create_time(const std::string& value);
  std::string* _internal_mutable_create_time();
  public:

  // @@protoc_insertion_point(class_scope:protomsg.ClusterNode)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cluster_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr server_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr server_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr node_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr node_ip_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr create_time_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_sysset_2eproto;
};
// -------------------------------------------------------------------

class ResourceConfig final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protomsg.ResourceConfig) */ {
 public:
  inline ResourceConfig() : ResourceConfig(nullptr) {}
  ~ResourceConfig() override;
  explicit constexpr ResourceConfig(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline ResourceConfig& operator=(const ResourceConfig& from) {
    CopyFrom(from);
    return *this;
  }
  inline ResourceConfig& operator=(ResourceConfig&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      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 ResourceConfig& default_instance() {
    return *internal_default_instance();
  }
  static inline const ResourceConfig* internal_default_instance() {
    return reinterpret_cast<const ResourceConfig*>(
               &_ResourceConfig_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(ResourceConfig& a, ResourceConfig& b) {
    a.Swap(&b);
  }
  inline void Swap(ResourceConfig* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ResourceConfig* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  inline ResourceConfig* New() const final {
    return new ResourceConfig();
  }

  ResourceConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ResourceConfig>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ResourceConfig& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ResourceConfig& 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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* 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(ResourceConfig* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "protomsg.ResourceConfig";
  }
  protected:
  explicit ResourceConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  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 {
    kServiceIpFieldNumber = 2,
    kDomainFieldNumber = 3,
    kIpTypeFieldNumber = 1,
    kFilePortFieldNumber = 4,
  };
  // string serviceIp = 2;
  void clear_serviceip();
  const std::string& serviceip() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_serviceip(ArgT0&& arg0, ArgT... args);
  std::string* mutable_serviceip();
  PROTOBUF_MUST_USE_RESULT std::string* release_serviceip();
  void set_allocated_serviceip(std::string* serviceip);
  private:
  const std::string& _internal_serviceip() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_serviceip(const std::string& value);
  std::string* _internal_mutable_serviceip();
  public:

  // string domain = 3;
  void clear_domain();
  const std::string& domain() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_domain(ArgT0&& arg0, ArgT... args);
  std::string* mutable_domain();
  PROTOBUF_MUST_USE_RESULT std::string* release_domain();
  void set_allocated_domain(std::string* domain);
  private:
  const std::string& _internal_domain() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_domain(const std::string& value);
  std::string* _internal_mutable_domain();
  public:

  // int32 ipType = 1;
  void clear_iptype();
  ::PROTOBUF_NAMESPACE_ID::int32 iptype() const;
  void set_iptype(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_iptype() const;
  void _internal_set_iptype(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 filePort = 4;
  void clear_fileport();
  ::PROTOBUF_NAMESPACE_ID::int32 fileport() const;
  void set_fileport(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_fileport() const;
  void _internal_set_fileport(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:protomsg.ResourceConfig)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr serviceip_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr domain_;
  ::PROTOBUF_NAMESPACE_ID::int32 iptype_;
  ::PROTOBUF_NAMESPACE_ID::int32 fileport_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_sysset_2eproto;
};
// -------------------------------------------------------------------

class Gb28181Config final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protomsg.Gb28181Config) */ {
 public:
  inline Gb28181Config() : Gb28181Config(nullptr) {}
  ~Gb28181Config() override;
  explicit constexpr Gb28181Config(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

  inline Gb28181Config& operator=(const Gb28181Config& from) {
    CopyFrom(from);
    return *this;
  }
  inline Gb28181Config& operator=(Gb28181Config&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      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 Gb28181Config& default_instance() {
    return *internal_default_instance();
  }
  static inline const Gb28181Config* internal_default_instance() {
    return reinterpret_cast<const Gb28181Config*>(
               &_Gb28181Config_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(Gb28181Config& a, Gb28181Config& b) {
    a.Swap(&b);
  }
  inline void Swap(Gb28181Config* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Gb28181Config* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  inline Gb28181Config* New() const final {
    return new Gb28181Config();
  }

  Gb28181Config* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Gb28181Config>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Gb28181Config& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Gb28181Config& 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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* 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(Gb28181Config* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "protomsg.Gb28181Config";
  }
  protected:
  explicit Gb28181Config(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

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

  enum : int {
    kIdFieldNumber = 1,
    kServerIpFieldNumber = 2,
    kServerPortFieldNumber = 3,
    kPublicIdFieldNumber = 4,
    kGbServerPortFieldNumber = 5,
    kPasswordFieldNumber = 7,
    kUpdateTimeFieldNumber = 8,
    kIsAuthFieldNumber = 6,
  };
  // string Id = 1;
  void clear_id();
  const std::string& id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_id();
  PROTOBUF_MUST_USE_RESULT std::string* release_id();
  void set_allocated_id(std::string* id);
  private:
  const std::string& _internal_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
  std::string* _internal_mutable_id();
  public:

  // string ServerIp = 2;
  void clear_serverip();
  const std::string& serverip() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_serverip(ArgT0&& arg0, ArgT... args);
  std::string* mutable_serverip();
  PROTOBUF_MUST_USE_RESULT std::string* release_serverip();
  void set_allocated_serverip(std::string* serverip);
  private:
  const std::string& _internal_serverip() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_serverip(const std::string& value);
  std::string* _internal_mutable_serverip();
  public:

  // string ServerPort = 3;
  void clear_serverport();
  const std::string& serverport() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_serverport(ArgT0&& arg0, ArgT... args);
  std::string* mutable_serverport();
  PROTOBUF_MUST_USE_RESULT std::string* release_serverport();
  void set_allocated_serverport(std::string* serverport);
  private:
  const std::string& _internal_serverport() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_serverport(const std::string& value);
  std::string* _internal_mutable_serverport();
  public:

  // string PublicId = 4;
  void clear_publicid();
  const std::string& publicid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_publicid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_publicid();
  PROTOBUF_MUST_USE_RESULT std::string* release_publicid();
  void set_allocated_publicid(std::string* publicid);
  private:
  const std::string& _internal_publicid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_publicid(const std::string& value);
  std::string* _internal_mutable_publicid();
  public:

  // string GbServerPort = 5;
  void clear_gbserverport();
  const std::string& gbserverport() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_gbserverport(ArgT0&& arg0, ArgT... args);
  std::string* mutable_gbserverport();
  PROTOBUF_MUST_USE_RESULT std::string* release_gbserverport();
  void set_allocated_gbserverport(std::string* gbserverport);
  private:
  const std::string& _internal_gbserverport() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_gbserverport(const std::string& value);
  std::string* _internal_mutable_gbserverport();
  public:

  // string Password = 7;
  void clear_password();
  const std::string& password() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_password(ArgT0&& arg0, ArgT... args);
  std::string* mutable_password();
  PROTOBUF_MUST_USE_RESULT std::string* release_password();
  void set_allocated_password(std::string* password);
  private:
  const std::string& _internal_password() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_password(const std::string& value);
  std::string* _internal_mutable_password();
  public:

  // string UpdateTime = 8;
  void clear_updatetime();
  const std::string& updatetime() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_updatetime(ArgT0&& arg0, ArgT... args);
  std::string* mutable_updatetime();
  PROTOBUF_MUST_USE_RESULT std::string* release_updatetime();
  void set_allocated_updatetime(std::string* updatetime);
  private:
  const std::string& _internal_updatetime() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_updatetime(const std::string& value);
  std::string* _internal_mutable_updatetime();
  public:

  // bool IsAuth = 6;
  void clear_isauth();
  bool isauth() const;
  void set_isauth(bool value);
  private:
  bool _internal_isauth() const;
  void _internal_set_isauth(bool value);
  public:

  // @@protoc_insertion_point(class_scope:protomsg.Gb28181Config)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr serverip_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr serverport_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr publicid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr gbserverport_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr password_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr updatetime_;
  bool isauth_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_sysset_2eproto;
};
// ===================================================================


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

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

// string server_id = 1;
inline void LocalConfig::clear_server_id() {
  server_id_.ClearToEmpty();
}
inline const std::string& LocalConfig::server_id() const {
  // @@protoc_insertion_point(field_get:protomsg.LocalConfig.server_id)
  return _internal_server_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LocalConfig::set_server_id(ArgT0&& arg0, ArgT... args) {
 
 server_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.LocalConfig.server_id)
}
inline std::string* LocalConfig::mutable_server_id() {
  std::string* _s = _internal_mutable_server_id();
  // @@protoc_insertion_point(field_mutable:protomsg.LocalConfig.server_id)
  return _s;
}
inline const std::string& LocalConfig::_internal_server_id() const {
  return server_id_.Get();
}
inline void LocalConfig::_internal_set_server_id(const std::string& value) {
  
  server_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LocalConfig::_internal_mutable_server_id() {
  
  return server_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LocalConfig::release_server_id() {
  // @@protoc_insertion_point(field_release:protomsg.LocalConfig.server_id)
  return server_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void LocalConfig::set_allocated_server_id(std::string* server_id) {
  if (server_id != nullptr) {
    
  } else {
    
  }
  server_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), server_id,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.LocalConfig.server_id)
}

// string server_name = 2;
inline void LocalConfig::clear_server_name() {
  server_name_.ClearToEmpty();
}
inline const std::string& LocalConfig::server_name() const {
  // @@protoc_insertion_point(field_get:protomsg.LocalConfig.server_name)
  return _internal_server_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LocalConfig::set_server_name(ArgT0&& arg0, ArgT... args) {
 
 server_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.LocalConfig.server_name)
}
inline std::string* LocalConfig::mutable_server_name() {
  std::string* _s = _internal_mutable_server_name();
  // @@protoc_insertion_point(field_mutable:protomsg.LocalConfig.server_name)
  return _s;
}
inline const std::string& LocalConfig::_internal_server_name() const {
  return server_name_.Get();
}
inline void LocalConfig::_internal_set_server_name(const std::string& value) {
  
  server_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LocalConfig::_internal_mutable_server_name() {
  
  return server_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LocalConfig::release_server_name() {
  // @@protoc_insertion_point(field_release:protomsg.LocalConfig.server_name)
  return server_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void LocalConfig::set_allocated_server_name(std::string* server_name) {
  if (server_name != nullptr) {
    
  } else {
    
  }
  server_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), server_name,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.LocalConfig.server_name)
}

// int32 server_type = 3;
inline void LocalConfig::clear_server_type() {
  server_type_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LocalConfig::_internal_server_type() const {
  return server_type_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LocalConfig::server_type() const {
  // @@protoc_insertion_point(field_get:protomsg.LocalConfig.server_type)
  return _internal_server_type();
}
inline void LocalConfig::_internal_set_server_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  server_type_ = value;
}
inline void LocalConfig::set_server_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_server_type(value);
  // @@protoc_insertion_point(field_set:protomsg.LocalConfig.server_type)
}

// string server_ip = 4;
inline void LocalConfig::clear_server_ip() {
  server_ip_.ClearToEmpty();
}
inline const std::string& LocalConfig::server_ip() const {
  // @@protoc_insertion_point(field_get:protomsg.LocalConfig.server_ip)
  return _internal_server_ip();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LocalConfig::set_server_ip(ArgT0&& arg0, ArgT... args) {
 
 server_ip_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.LocalConfig.server_ip)
}
inline std::string* LocalConfig::mutable_server_ip() {
  std::string* _s = _internal_mutable_server_ip();
  // @@protoc_insertion_point(field_mutable:protomsg.LocalConfig.server_ip)
  return _s;
}
inline const std::string& LocalConfig::_internal_server_ip() const {
  return server_ip_.Get();
}
inline void LocalConfig::_internal_set_server_ip(const std::string& value) {
  
  server_ip_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LocalConfig::_internal_mutable_server_ip() {
  
  return server_ip_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LocalConfig::release_server_ip() {
  // @@protoc_insertion_point(field_release:protomsg.LocalConfig.server_ip)
  return server_ip_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void LocalConfig::set_allocated_server_ip(std::string* server_ip) {
  if (server_ip != nullptr) {
    
  } else {
    
  }
  server_ip_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), server_ip,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.LocalConfig.server_ip)
}

// string alarm_ip = 5;
inline void LocalConfig::clear_alarm_ip() {
  alarm_ip_.ClearToEmpty();
}
inline const std::string& LocalConfig::alarm_ip() const {
  // @@protoc_insertion_point(field_get:protomsg.LocalConfig.alarm_ip)
  return _internal_alarm_ip();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LocalConfig::set_alarm_ip(ArgT0&& arg0, ArgT... args) {
 
 alarm_ip_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.LocalConfig.alarm_ip)
}
inline std::string* LocalConfig::mutable_alarm_ip() {
  std::string* _s = _internal_mutable_alarm_ip();
  // @@protoc_insertion_point(field_mutable:protomsg.LocalConfig.alarm_ip)
  return _s;
}
inline const std::string& LocalConfig::_internal_alarm_ip() const {
  return alarm_ip_.Get();
}
inline void LocalConfig::_internal_set_alarm_ip(const std::string& value) {
  
  alarm_ip_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LocalConfig::_internal_mutable_alarm_ip() {
  
  return alarm_ip_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LocalConfig::release_alarm_ip() {
  // @@protoc_insertion_point(field_release:protomsg.LocalConfig.alarm_ip)
  return alarm_ip_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void LocalConfig::set_allocated_alarm_ip(std::string* alarm_ip) {
  if (alarm_ip != nullptr) {
    
  } else {
    
  }
  alarm_ip_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), alarm_ip,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.LocalConfig.alarm_ip)
}

// int32 alarm_port = 6;
inline void LocalConfig::clear_alarm_port() {
  alarm_port_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LocalConfig::_internal_alarm_port() const {
  return alarm_port_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LocalConfig::alarm_port() const {
  // @@protoc_insertion_point(field_get:protomsg.LocalConfig.alarm_port)
  return _internal_alarm_port();
}
inline void LocalConfig::_internal_set_alarm_port(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  alarm_port_ = value;
}
inline void LocalConfig::set_alarm_port(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_alarm_port(value);
  // @@protoc_insertion_point(field_set:protomsg.LocalConfig.alarm_port)
}

// string web_pic_ip = 7;
inline void LocalConfig::clear_web_pic_ip() {
  web_pic_ip_.ClearToEmpty();
}
inline const std::string& LocalConfig::web_pic_ip() const {
  // @@protoc_insertion_point(field_get:protomsg.LocalConfig.web_pic_ip)
  return _internal_web_pic_ip();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LocalConfig::set_web_pic_ip(ArgT0&& arg0, ArgT... args) {
 
 web_pic_ip_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.LocalConfig.web_pic_ip)
}
inline std::string* LocalConfig::mutable_web_pic_ip() {
  std::string* _s = _internal_mutable_web_pic_ip();
  // @@protoc_insertion_point(field_mutable:protomsg.LocalConfig.web_pic_ip)
  return _s;
}
inline const std::string& LocalConfig::_internal_web_pic_ip() const {
  return web_pic_ip_.Get();
}
inline void LocalConfig::_internal_set_web_pic_ip(const std::string& value) {
  
  web_pic_ip_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LocalConfig::_internal_mutable_web_pic_ip() {
  
  return web_pic_ip_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LocalConfig::release_web_pic_ip() {
  // @@protoc_insertion_point(field_release:protomsg.LocalConfig.web_pic_ip)
  return web_pic_ip_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void LocalConfig::set_allocated_web_pic_ip(std::string* web_pic_ip) {
  if (web_pic_ip != nullptr) {
    
  } else {
    
  }
  web_pic_ip_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), web_pic_ip,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.LocalConfig.web_pic_ip)
}

// int32 web_pic_port = 8;
inline void LocalConfig::clear_web_pic_port() {
  web_pic_port_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LocalConfig::_internal_web_pic_port() const {
  return web_pic_port_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LocalConfig::web_pic_port() const {
  // @@protoc_insertion_point(field_get:protomsg.LocalConfig.web_pic_port)
  return _internal_web_pic_port();
}
inline void LocalConfig::_internal_set_web_pic_port(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  web_pic_port_ = value;
}
inline void LocalConfig::set_web_pic_port(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_web_pic_port(value);
  // @@protoc_insertion_point(field_set:protomsg.LocalConfig.web_pic_port)
}

// string es_pic_ip = 9;
inline void LocalConfig::clear_es_pic_ip() {
  es_pic_ip_.ClearToEmpty();
}
inline const std::string& LocalConfig::es_pic_ip() const {
  // @@protoc_insertion_point(field_get:protomsg.LocalConfig.es_pic_ip)
  return _internal_es_pic_ip();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LocalConfig::set_es_pic_ip(ArgT0&& arg0, ArgT... args) {
 
 es_pic_ip_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.LocalConfig.es_pic_ip)
}
inline std::string* LocalConfig::mutable_es_pic_ip() {
  std::string* _s = _internal_mutable_es_pic_ip();
  // @@protoc_insertion_point(field_mutable:protomsg.LocalConfig.es_pic_ip)
  return _s;
}
inline const std::string& LocalConfig::_internal_es_pic_ip() const {
  return es_pic_ip_.Get();
}
inline void LocalConfig::_internal_set_es_pic_ip(const std::string& value) {
  
  es_pic_ip_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LocalConfig::_internal_mutable_es_pic_ip() {
  
  return es_pic_ip_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LocalConfig::release_es_pic_ip() {
  // @@protoc_insertion_point(field_release:protomsg.LocalConfig.es_pic_ip)
  return es_pic_ip_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void LocalConfig::set_allocated_es_pic_ip(std::string* es_pic_ip) {
  if (es_pic_ip != nullptr) {
    
  } else {
    
  }
  es_pic_ip_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), es_pic_ip,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.LocalConfig.es_pic_ip)
}

// int32 es_pic_port = 10;
inline void LocalConfig::clear_es_pic_port() {
  es_pic_port_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LocalConfig::_internal_es_pic_port() const {
  return es_pic_port_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LocalConfig::es_pic_port() const {
  // @@protoc_insertion_point(field_get:protomsg.LocalConfig.es_pic_port)
  return _internal_es_pic_port();
}
inline void LocalConfig::_internal_set_es_pic_port(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  es_pic_port_ = value;
}
inline void LocalConfig::set_es_pic_port(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_es_pic_port(value);
  // @@protoc_insertion_point(field_set:protomsg.LocalConfig.es_pic_port)
}

// int32 cut_max_duration = 11;
inline void LocalConfig::clear_cut_max_duration() {
  cut_max_duration_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LocalConfig::_internal_cut_max_duration() const {
  return cut_max_duration_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LocalConfig::cut_max_duration() const {
  // @@protoc_insertion_point(field_get:protomsg.LocalConfig.cut_max_duration)
  return _internal_cut_max_duration();
}
inline void LocalConfig::_internal_set_cut_max_duration(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  cut_max_duration_ = value;
}
inline void LocalConfig::set_cut_max_duration(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_cut_max_duration(value);
  // @@protoc_insertion_point(field_set:protomsg.LocalConfig.cut_max_duration)
}

// int32 cut_min_duration = 12;
inline void LocalConfig::clear_cut_min_duration() {
  cut_min_duration_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LocalConfig::_internal_cut_min_duration() const {
  return cut_min_duration_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LocalConfig::cut_min_duration() const {
  // @@protoc_insertion_point(field_get:protomsg.LocalConfig.cut_min_duration)
  return _internal_cut_min_duration();
}
inline void LocalConfig::_internal_set_cut_min_duration(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  cut_min_duration_ = value;
}
inline void LocalConfig::set_cut_min_duration(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_cut_min_duration(value);
  // @@protoc_insertion_point(field_set:protomsg.LocalConfig.cut_min_duration)
}

// string reserved = 13;
inline void LocalConfig::clear_reserved() {
  reserved_.ClearToEmpty();
}
inline const std::string& LocalConfig::reserved() const {
  // @@protoc_insertion_point(field_get:protomsg.LocalConfig.reserved)
  return _internal_reserved();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LocalConfig::set_reserved(ArgT0&& arg0, ArgT... args) {
 
 reserved_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.LocalConfig.reserved)
}
inline std::string* LocalConfig::mutable_reserved() {
  std::string* _s = _internal_mutable_reserved();
  // @@protoc_insertion_point(field_mutable:protomsg.LocalConfig.reserved)
  return _s;
}
inline const std::string& LocalConfig::_internal_reserved() const {
  return reserved_.Get();
}
inline void LocalConfig::_internal_set_reserved(const std::string& value) {
  
  reserved_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LocalConfig::_internal_mutable_reserved() {
  
  return reserved_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LocalConfig::release_reserved() {
  // @@protoc_insertion_point(field_release:protomsg.LocalConfig.reserved)
  return reserved_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void LocalConfig::set_allocated_reserved(std::string* reserved) {
  if (reserved != nullptr) {
    
  } else {
    
  }
  reserved_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), reserved,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.LocalConfig.reserved)
}

// string gate_way = 14;
inline void LocalConfig::clear_gate_way() {
  gate_way_.ClearToEmpty();
}
inline const std::string& LocalConfig::gate_way() const {
  // @@protoc_insertion_point(field_get:protomsg.LocalConfig.gate_way)
  return _internal_gate_way();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LocalConfig::set_gate_way(ArgT0&& arg0, ArgT... args) {
 
 gate_way_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.LocalConfig.gate_way)
}
inline std::string* LocalConfig::mutable_gate_way() {
  std::string* _s = _internal_mutable_gate_way();
  // @@protoc_insertion_point(field_mutable:protomsg.LocalConfig.gate_way)
  return _s;
}
inline const std::string& LocalConfig::_internal_gate_way() const {
  return gate_way_.Get();
}
inline void LocalConfig::_internal_set_gate_way(const std::string& value) {
  
  gate_way_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LocalConfig::_internal_mutable_gate_way() {
  
  return gate_way_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LocalConfig::release_gate_way() {
  // @@protoc_insertion_point(field_release:protomsg.LocalConfig.gate_way)
  return gate_way_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void LocalConfig::set_allocated_gate_way(std::string* gate_way) {
  if (gate_way != nullptr) {
    
  } else {
    
  }
  gate_way_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), gate_way,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.LocalConfig.gate_way)
}

// string net_mask = 15;
inline void LocalConfig::clear_net_mask() {
  net_mask_.ClearToEmpty();
}
inline const std::string& LocalConfig::net_mask() const {
  // @@protoc_insertion_point(field_get:protomsg.LocalConfig.net_mask)
  return _internal_net_mask();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LocalConfig::set_net_mask(ArgT0&& arg0, ArgT... args) {
 
 net_mask_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.LocalConfig.net_mask)
}
inline std::string* LocalConfig::mutable_net_mask() {
  std::string* _s = _internal_mutable_net_mask();
  // @@protoc_insertion_point(field_mutable:protomsg.LocalConfig.net_mask)
  return _s;
}
inline const std::string& LocalConfig::_internal_net_mask() const {
  return net_mask_.Get();
}
inline void LocalConfig::_internal_set_net_mask(const std::string& value) {
  
  net_mask_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LocalConfig::_internal_mutable_net_mask() {
  
  return net_mask_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LocalConfig::release_net_mask() {
  // @@protoc_insertion_point(field_release:protomsg.LocalConfig.net_mask)
  return net_mask_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void LocalConfig::set_allocated_net_mask(std::string* net_mask) {
  if (net_mask != nullptr) {
    
  } else {
    
  }
  net_mask_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), net_mask,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.LocalConfig.net_mask)
}

// int32 real_max = 16;
inline void LocalConfig::clear_real_max() {
  real_max_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LocalConfig::_internal_real_max() const {
  return real_max_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LocalConfig::real_max() const {
  // @@protoc_insertion_point(field_get:protomsg.LocalConfig.real_max)
  return _internal_real_max();
}
inline void LocalConfig::_internal_set_real_max(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  real_max_ = value;
}
inline void LocalConfig::set_real_max(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_real_max(value);
  // @@protoc_insertion_point(field_set:protomsg.LocalConfig.real_max)
}

// int32 alarm_threshold_type = 17;
inline void LocalConfig::clear_alarm_threshold_type() {
  alarm_threshold_type_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LocalConfig::_internal_alarm_threshold_type() const {
  return alarm_threshold_type_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LocalConfig::alarm_threshold_type() const {
  // @@protoc_insertion_point(field_get:protomsg.LocalConfig.alarm_threshold_type)
  return _internal_alarm_threshold_type();
}
inline void LocalConfig::_internal_set_alarm_threshold_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  alarm_threshold_type_ = value;
}
inline void LocalConfig::set_alarm_threshold_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_alarm_threshold_type(value);
  // @@protoc_insertion_point(field_set:protomsg.LocalConfig.alarm_threshold_type)
}

// int32 alarm_threshold = 18;
inline void LocalConfig::clear_alarm_threshold() {
  alarm_threshold_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LocalConfig::_internal_alarm_threshold() const {
  return alarm_threshold_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 LocalConfig::alarm_threshold() const {
  // @@protoc_insertion_point(field_get:protomsg.LocalConfig.alarm_threshold)
  return _internal_alarm_threshold();
}
inline void LocalConfig::_internal_set_alarm_threshold(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  alarm_threshold_ = value;
}
inline void LocalConfig::set_alarm_threshold(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_alarm_threshold(value);
  // @@protoc_insertion_point(field_set:protomsg.LocalConfig.alarm_threshold)
}

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

// PollConfig

// string server_id = 1;
inline void PollConfig::clear_server_id() {
  server_id_.ClearToEmpty();
}
inline const std::string& PollConfig::server_id() const {
  // @@protoc_insertion_point(field_get:protomsg.PollConfig.server_id)
  return _internal_server_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PollConfig::set_server_id(ArgT0&& arg0, ArgT... args) {
 
 server_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.PollConfig.server_id)
}
inline std::string* PollConfig::mutable_server_id() {
  std::string* _s = _internal_mutable_server_id();
  // @@protoc_insertion_point(field_mutable:protomsg.PollConfig.server_id)
  return _s;
}
inline const std::string& PollConfig::_internal_server_id() const {
  return server_id_.Get();
}
inline void PollConfig::_internal_set_server_id(const std::string& value) {
  
  server_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* PollConfig::_internal_mutable_server_id() {
  
  return server_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* PollConfig::release_server_id() {
  // @@protoc_insertion_point(field_release:protomsg.PollConfig.server_id)
  return server_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void PollConfig::set_allocated_server_id(std::string* server_id) {
  if (server_id != nullptr) {
    
  } else {
    
  }
  server_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), server_id,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.PollConfig.server_id)
}

// int32 poll_period = 2;
inline void PollConfig::clear_poll_period() {
  poll_period_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 PollConfig::_internal_poll_period() const {
  return poll_period_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 PollConfig::poll_period() const {
  // @@protoc_insertion_point(field_get:protomsg.PollConfig.poll_period)
  return _internal_poll_period();
}
inline void PollConfig::_internal_set_poll_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  poll_period_ = value;
}
inline void PollConfig::set_poll_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_poll_period(value);
  // @@protoc_insertion_point(field_set:protomsg.PollConfig.poll_period)
}

// int32 delay = 3;
inline void PollConfig::clear_delay() {
  delay_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 PollConfig::_internal_delay() const {
  return delay_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 PollConfig::delay() const {
  // @@protoc_insertion_point(field_get:protomsg.PollConfig.delay)
  return _internal_delay();
}
inline void PollConfig::_internal_set_delay(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  delay_ = value;
}
inline void PollConfig::set_delay(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_delay(value);
  // @@protoc_insertion_point(field_set:protomsg.PollConfig.delay)
}

// bool enable = 4;
inline void PollConfig::clear_enable() {
  enable_ = false;
}
inline bool PollConfig::_internal_enable() const {
  return enable_;
}
inline bool PollConfig::enable() const {
  // @@protoc_insertion_point(field_get:protomsg.PollConfig.enable)
  return _internal_enable();
}
inline void PollConfig::_internal_set_enable(bool value) {
  
  enable_ = value;
}
inline void PollConfig::set_enable(bool value) {
  _internal_set_enable(value);
  // @@protoc_insertion_point(field_set:protomsg.PollConfig.enable)
}

// int32 pollChannelCount = 5;
inline void PollConfig::clear_pollchannelcount() {
  pollchannelcount_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 PollConfig::_internal_pollchannelcount() const {
  return pollchannelcount_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 PollConfig::pollchannelcount() const {
  // @@protoc_insertion_point(field_get:protomsg.PollConfig.pollChannelCount)
  return _internal_pollchannelcount();
}
inline void PollConfig::_internal_set_pollchannelcount(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  pollchannelcount_ = value;
}
inline void PollConfig::set_pollchannelcount(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_pollchannelcount(value);
  // @@protoc_insertion_point(field_set:protomsg.PollConfig.pollChannelCount)
}

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

// Cluster

// string cluster_id = 1;
inline void Cluster::clear_cluster_id() {
  cluster_id_.ClearToEmpty();
}
inline const std::string& Cluster::cluster_id() const {
  // @@protoc_insertion_point(field_get:protomsg.Cluster.cluster_id)
  return _internal_cluster_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Cluster::set_cluster_id(ArgT0&& arg0, ArgT... args) {
 
 cluster_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.Cluster.cluster_id)
}
inline std::string* Cluster::mutable_cluster_id() {
  std::string* _s = _internal_mutable_cluster_id();
  // @@protoc_insertion_point(field_mutable:protomsg.Cluster.cluster_id)
  return _s;
}
inline const std::string& Cluster::_internal_cluster_id() const {
  return cluster_id_.Get();
}
inline void Cluster::_internal_set_cluster_id(const std::string& value) {
  
  cluster_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Cluster::_internal_mutable_cluster_id() {
  
  return cluster_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Cluster::release_cluster_id() {
  // @@protoc_insertion_point(field_release:protomsg.Cluster.cluster_id)
  return cluster_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Cluster::set_allocated_cluster_id(std::string* cluster_id) {
  if (cluster_id != nullptr) {
    
  } else {
    
  }
  cluster_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cluster_id,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.Cluster.cluster_id)
}

// string cluster_name = 2;
inline void Cluster::clear_cluster_name() {
  cluster_name_.ClearToEmpty();
}
inline const std::string& Cluster::cluster_name() const {
  // @@protoc_insertion_point(field_get:protomsg.Cluster.cluster_name)
  return _internal_cluster_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Cluster::set_cluster_name(ArgT0&& arg0, ArgT... args) {
 
 cluster_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.Cluster.cluster_name)
}
inline std::string* Cluster::mutable_cluster_name() {
  std::string* _s = _internal_mutable_cluster_name();
  // @@protoc_insertion_point(field_mutable:protomsg.Cluster.cluster_name)
  return _s;
}
inline const std::string& Cluster::_internal_cluster_name() const {
  return cluster_name_.Get();
}
inline void Cluster::_internal_set_cluster_name(const std::string& value) {
  
  cluster_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Cluster::_internal_mutable_cluster_name() {
  
  return cluster_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Cluster::release_cluster_name() {
  // @@protoc_insertion_point(field_release:protomsg.Cluster.cluster_name)
  return cluster_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Cluster::set_allocated_cluster_name(std::string* cluster_name) {
  if (cluster_name != nullptr) {
    
  } else {
    
  }
  cluster_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cluster_name,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.Cluster.cluster_name)
}

// string password = 3;
inline void Cluster::clear_password() {
  password_.ClearToEmpty();
}
inline const std::string& Cluster::password() const {
  // @@protoc_insertion_point(field_get:protomsg.Cluster.password)
  return _internal_password();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Cluster::set_password(ArgT0&& arg0, ArgT... args) {
 
 password_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.Cluster.password)
}
inline std::string* Cluster::mutable_password() {
  std::string* _s = _internal_mutable_password();
  // @@protoc_insertion_point(field_mutable:protomsg.Cluster.password)
  return _s;
}
inline const std::string& Cluster::_internal_password() const {
  return password_.Get();
}
inline void Cluster::_internal_set_password(const std::string& value) {
  
  password_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Cluster::_internal_mutable_password() {
  
  return password_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Cluster::release_password() {
  // @@protoc_insertion_point(field_release:protomsg.Cluster.password)
  return password_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Cluster::set_allocated_password(std::string* password) {
  if (password != nullptr) {
    
  } else {
    
  }
  password_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), password,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.Cluster.password)
}

// string virtual_ip = 4;
inline void Cluster::clear_virtual_ip() {
  virtual_ip_.ClearToEmpty();
}
inline const std::string& Cluster::virtual_ip() const {
  // @@protoc_insertion_point(field_get:protomsg.Cluster.virtual_ip)
  return _internal_virtual_ip();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Cluster::set_virtual_ip(ArgT0&& arg0, ArgT... args) {
 
 virtual_ip_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.Cluster.virtual_ip)
}
inline std::string* Cluster::mutable_virtual_ip() {
  std::string* _s = _internal_mutable_virtual_ip();
  // @@protoc_insertion_point(field_mutable:protomsg.Cluster.virtual_ip)
  return _s;
}
inline const std::string& Cluster::_internal_virtual_ip() const {
  return virtual_ip_.Get();
}
inline void Cluster::_internal_set_virtual_ip(const std::string& value) {
  
  virtual_ip_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Cluster::_internal_mutable_virtual_ip() {
  
  return virtual_ip_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Cluster::release_virtual_ip() {
  // @@protoc_insertion_point(field_release:protomsg.Cluster.virtual_ip)
  return virtual_ip_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Cluster::set_allocated_virtual_ip(std::string* virtual_ip) {
  if (virtual_ip != nullptr) {
    
  } else {
    
  }
  virtual_ip_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), virtual_ip,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.Cluster.virtual_ip)
}

// repeated .protomsg.ClusterNode nodes = 5;
inline int Cluster::_internal_nodes_size() const {
  return nodes_.size();
}
inline int Cluster::nodes_size() const {
  return _internal_nodes_size();
}
inline void Cluster::clear_nodes() {
  nodes_.Clear();
}
inline ::protomsg::ClusterNode* Cluster::mutable_nodes(int index) {
  // @@protoc_insertion_point(field_mutable:protomsg.Cluster.nodes)
  return nodes_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protomsg::ClusterNode >*
Cluster::mutable_nodes() {
  // @@protoc_insertion_point(field_mutable_list:protomsg.Cluster.nodes)
  return &nodes_;
}
inline const ::protomsg::ClusterNode& Cluster::_internal_nodes(int index) const {
  return nodes_.Get(index);
}
inline const ::protomsg::ClusterNode& Cluster::nodes(int index) const {
  // @@protoc_insertion_point(field_get:protomsg.Cluster.nodes)
  return _internal_nodes(index);
}
inline ::protomsg::ClusterNode* Cluster::_internal_add_nodes() {
  return nodes_.Add();
}
inline ::protomsg::ClusterNode* Cluster::add_nodes() {
  ::protomsg::ClusterNode* _add = _internal_add_nodes();
  // @@protoc_insertion_point(field_add:protomsg.Cluster.nodes)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protomsg::ClusterNode >&
Cluster::nodes() const {
  // @@protoc_insertion_point(field_list:protomsg.Cluster.nodes)
  return nodes_;
}

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

// ClusterNode

// string id = 1;
inline void ClusterNode::clear_id() {
  id_.ClearToEmpty();
}
inline const std::string& ClusterNode::id() const {
  // @@protoc_insertion_point(field_get:protomsg.ClusterNode.id)
  return _internal_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClusterNode::set_id(ArgT0&& arg0, ArgT... args) {
 
 id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.ClusterNode.id)
}
inline std::string* ClusterNode::mutable_id() {
  std::string* _s = _internal_mutable_id();
  // @@protoc_insertion_point(field_mutable:protomsg.ClusterNode.id)
  return _s;
}
inline const std::string& ClusterNode::_internal_id() const {
  return id_.Get();
}
inline void ClusterNode::_internal_set_id(const std::string& value) {
  
  id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ClusterNode::_internal_mutable_id() {
  
  return id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ClusterNode::release_id() {
  // @@protoc_insertion_point(field_release:protomsg.ClusterNode.id)
  return id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void ClusterNode::set_allocated_id(std::string* id) {
  if (id != nullptr) {
    
  } else {
    
  }
  id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), id,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.ClusterNode.id)
}

// string cluster_id = 2;
inline void ClusterNode::clear_cluster_id() {
  cluster_id_.ClearToEmpty();
}
inline const std::string& ClusterNode::cluster_id() const {
  // @@protoc_insertion_point(field_get:protomsg.ClusterNode.cluster_id)
  return _internal_cluster_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClusterNode::set_cluster_id(ArgT0&& arg0, ArgT... args) {
 
 cluster_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.ClusterNode.cluster_id)
}
inline std::string* ClusterNode::mutable_cluster_id() {
  std::string* _s = _internal_mutable_cluster_id();
  // @@protoc_insertion_point(field_mutable:protomsg.ClusterNode.cluster_id)
  return _s;
}
inline const std::string& ClusterNode::_internal_cluster_id() const {
  return cluster_id_.Get();
}
inline void ClusterNode::_internal_set_cluster_id(const std::string& value) {
  
  cluster_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ClusterNode::_internal_mutable_cluster_id() {
  
  return cluster_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ClusterNode::release_cluster_id() {
  // @@protoc_insertion_point(field_release:protomsg.ClusterNode.cluster_id)
  return cluster_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void ClusterNode::set_allocated_cluster_id(std::string* cluster_id) {
  if (cluster_id != nullptr) {
    
  } else {
    
  }
  cluster_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cluster_id,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.ClusterNode.cluster_id)
}

// string server_id = 3;
inline void ClusterNode::clear_server_id() {
  server_id_.ClearToEmpty();
}
inline const std::string& ClusterNode::server_id() const {
  // @@protoc_insertion_point(field_get:protomsg.ClusterNode.server_id)
  return _internal_server_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClusterNode::set_server_id(ArgT0&& arg0, ArgT... args) {
 
 server_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.ClusterNode.server_id)
}
inline std::string* ClusterNode::mutable_server_id() {
  std::string* _s = _internal_mutable_server_id();
  // @@protoc_insertion_point(field_mutable:protomsg.ClusterNode.server_id)
  return _s;
}
inline const std::string& ClusterNode::_internal_server_id() const {
  return server_id_.Get();
}
inline void ClusterNode::_internal_set_server_id(const std::string& value) {
  
  server_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ClusterNode::_internal_mutable_server_id() {
  
  return server_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ClusterNode::release_server_id() {
  // @@protoc_insertion_point(field_release:protomsg.ClusterNode.server_id)
  return server_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void ClusterNode::set_allocated_server_id(std::string* server_id) {
  if (server_id != nullptr) {
    
  } else {
    
  }
  server_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), server_id,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.ClusterNode.server_id)
}

// string server_name = 4;
inline void ClusterNode::clear_server_name() {
  server_name_.ClearToEmpty();
}
inline const std::string& ClusterNode::server_name() const {
  // @@protoc_insertion_point(field_get:protomsg.ClusterNode.server_name)
  return _internal_server_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClusterNode::set_server_name(ArgT0&& arg0, ArgT... args) {
 
 server_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.ClusterNode.server_name)
}
inline std::string* ClusterNode::mutable_server_name() {
  std::string* _s = _internal_mutable_server_name();
  // @@protoc_insertion_point(field_mutable:protomsg.ClusterNode.server_name)
  return _s;
}
inline const std::string& ClusterNode::_internal_server_name() const {
  return server_name_.Get();
}
inline void ClusterNode::_internal_set_server_name(const std::string& value) {
  
  server_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ClusterNode::_internal_mutable_server_name() {
  
  return server_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ClusterNode::release_server_name() {
  // @@protoc_insertion_point(field_release:protomsg.ClusterNode.server_name)
  return server_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void ClusterNode::set_allocated_server_name(std::string* server_name) {
  if (server_name != nullptr) {
    
  } else {
    
  }
  server_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), server_name,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.ClusterNode.server_name)
}

// string node_id = 5;
inline void ClusterNode::clear_node_id() {
  node_id_.ClearToEmpty();
}
inline const std::string& ClusterNode::node_id() const {
  // @@protoc_insertion_point(field_get:protomsg.ClusterNode.node_id)
  return _internal_node_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClusterNode::set_node_id(ArgT0&& arg0, ArgT... args) {
 
 node_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.ClusterNode.node_id)
}
inline std::string* ClusterNode::mutable_node_id() {
  std::string* _s = _internal_mutable_node_id();
  // @@protoc_insertion_point(field_mutable:protomsg.ClusterNode.node_id)
  return _s;
}
inline const std::string& ClusterNode::_internal_node_id() const {
  return node_id_.Get();
}
inline void ClusterNode::_internal_set_node_id(const std::string& value) {
  
  node_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ClusterNode::_internal_mutable_node_id() {
  
  return node_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ClusterNode::release_node_id() {
  // @@protoc_insertion_point(field_release:protomsg.ClusterNode.node_id)
  return node_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void ClusterNode::set_allocated_node_id(std::string* node_id) {
  if (node_id != nullptr) {
    
  } else {
    
  }
  node_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), node_id,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.ClusterNode.node_id)
}

// string node_ip = 6;
inline void ClusterNode::clear_node_ip() {
  node_ip_.ClearToEmpty();
}
inline const std::string& ClusterNode::node_ip() const {
  // @@protoc_insertion_point(field_get:protomsg.ClusterNode.node_ip)
  return _internal_node_ip();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClusterNode::set_node_ip(ArgT0&& arg0, ArgT... args) {
 
 node_ip_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.ClusterNode.node_ip)
}
inline std::string* ClusterNode::mutable_node_ip() {
  std::string* _s = _internal_mutable_node_ip();
  // @@protoc_insertion_point(field_mutable:protomsg.ClusterNode.node_ip)
  return _s;
}
inline const std::string& ClusterNode::_internal_node_ip() const {
  return node_ip_.Get();
}
inline void ClusterNode::_internal_set_node_ip(const std::string& value) {
  
  node_ip_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ClusterNode::_internal_mutable_node_ip() {
  
  return node_ip_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ClusterNode::release_node_ip() {
  // @@protoc_insertion_point(field_release:protomsg.ClusterNode.node_ip)
  return node_ip_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void ClusterNode::set_allocated_node_ip(std::string* node_ip) {
  if (node_ip != nullptr) {
    
  } else {
    
  }
  node_ip_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), node_ip,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.ClusterNode.node_ip)
}

// string create_time = 7;
inline void ClusterNode::clear_create_time() {
  create_time_.ClearToEmpty();
}
inline const std::string& ClusterNode::create_time() const {
  // @@protoc_insertion_point(field_get:protomsg.ClusterNode.create_time)
  return _internal_create_time();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClusterNode::set_create_time(ArgT0&& arg0, ArgT... args) {
 
 create_time_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.ClusterNode.create_time)
}
inline std::string* ClusterNode::mutable_create_time() {
  std::string* _s = _internal_mutable_create_time();
  // @@protoc_insertion_point(field_mutable:protomsg.ClusterNode.create_time)
  return _s;
}
inline const std::string& ClusterNode::_internal_create_time() const {
  return create_time_.Get();
}
inline void ClusterNode::_internal_set_create_time(const std::string& value) {
  
  create_time_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ClusterNode::_internal_mutable_create_time() {
  
  return create_time_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ClusterNode::release_create_time() {
  // @@protoc_insertion_point(field_release:protomsg.ClusterNode.create_time)
  return create_time_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void ClusterNode::set_allocated_create_time(std::string* create_time) {
  if (create_time != nullptr) {
    
  } else {
    
  }
  create_time_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), create_time,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.ClusterNode.create_time)
}

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

// ResourceConfig

// int32 ipType = 1;
inline void ResourceConfig::clear_iptype() {
  iptype_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ResourceConfig::_internal_iptype() const {
  return iptype_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ResourceConfig::iptype() const {
  // @@protoc_insertion_point(field_get:protomsg.ResourceConfig.ipType)
  return _internal_iptype();
}
inline void ResourceConfig::_internal_set_iptype(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  iptype_ = value;
}
inline void ResourceConfig::set_iptype(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_iptype(value);
  // @@protoc_insertion_point(field_set:protomsg.ResourceConfig.ipType)
}

// string serviceIp = 2;
inline void ResourceConfig::clear_serviceip() {
  serviceip_.ClearToEmpty();
}
inline const std::string& ResourceConfig::serviceip() const {
  // @@protoc_insertion_point(field_get:protomsg.ResourceConfig.serviceIp)
  return _internal_serviceip();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ResourceConfig::set_serviceip(ArgT0&& arg0, ArgT... args) {
 
 serviceip_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.ResourceConfig.serviceIp)
}
inline std::string* ResourceConfig::mutable_serviceip() {
  std::string* _s = _internal_mutable_serviceip();
  // @@protoc_insertion_point(field_mutable:protomsg.ResourceConfig.serviceIp)
  return _s;
}
inline const std::string& ResourceConfig::_internal_serviceip() const {
  return serviceip_.Get();
}
inline void ResourceConfig::_internal_set_serviceip(const std::string& value) {
  
  serviceip_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ResourceConfig::_internal_mutable_serviceip() {
  
  return serviceip_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ResourceConfig::release_serviceip() {
  // @@protoc_insertion_point(field_release:protomsg.ResourceConfig.serviceIp)
  return serviceip_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void ResourceConfig::set_allocated_serviceip(std::string* serviceip) {
  if (serviceip != nullptr) {
    
  } else {
    
  }
  serviceip_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), serviceip,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.ResourceConfig.serviceIp)
}

// string domain = 3;
inline void ResourceConfig::clear_domain() {
  domain_.ClearToEmpty();
}
inline const std::string& ResourceConfig::domain() const {
  // @@protoc_insertion_point(field_get:protomsg.ResourceConfig.domain)
  return _internal_domain();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ResourceConfig::set_domain(ArgT0&& arg0, ArgT... args) {
 
 domain_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.ResourceConfig.domain)
}
inline std::string* ResourceConfig::mutable_domain() {
  std::string* _s = _internal_mutable_domain();
  // @@protoc_insertion_point(field_mutable:protomsg.ResourceConfig.domain)
  return _s;
}
inline const std::string& ResourceConfig::_internal_domain() const {
  return domain_.Get();
}
inline void ResourceConfig::_internal_set_domain(const std::string& value) {
  
  domain_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ResourceConfig::_internal_mutable_domain() {
  
  return domain_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ResourceConfig::release_domain() {
  // @@protoc_insertion_point(field_release:protomsg.ResourceConfig.domain)
  return domain_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void ResourceConfig::set_allocated_domain(std::string* domain) {
  if (domain != nullptr) {
    
  } else {
    
  }
  domain_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), domain,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.ResourceConfig.domain)
}

// int32 filePort = 4;
inline void ResourceConfig::clear_fileport() {
  fileport_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ResourceConfig::_internal_fileport() const {
  return fileport_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ResourceConfig::fileport() const {
  // @@protoc_insertion_point(field_get:protomsg.ResourceConfig.filePort)
  return _internal_fileport();
}
inline void ResourceConfig::_internal_set_fileport(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  fileport_ = value;
}
inline void ResourceConfig::set_fileport(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_fileport(value);
  // @@protoc_insertion_point(field_set:protomsg.ResourceConfig.filePort)
}

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

// Gb28181Config

// string Id = 1;
inline void Gb28181Config::clear_id() {
  id_.ClearToEmpty();
}
inline const std::string& Gb28181Config::id() const {
  // @@protoc_insertion_point(field_get:protomsg.Gb28181Config.Id)
  return _internal_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Gb28181Config::set_id(ArgT0&& arg0, ArgT... args) {
 
 id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.Gb28181Config.Id)
}
inline std::string* Gb28181Config::mutable_id() {
  std::string* _s = _internal_mutable_id();
  // @@protoc_insertion_point(field_mutable:protomsg.Gb28181Config.Id)
  return _s;
}
inline const std::string& Gb28181Config::_internal_id() const {
  return id_.Get();
}
inline void Gb28181Config::_internal_set_id(const std::string& value) {
  
  id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Gb28181Config::_internal_mutable_id() {
  
  return id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Gb28181Config::release_id() {
  // @@protoc_insertion_point(field_release:protomsg.Gb28181Config.Id)
  return id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Gb28181Config::set_allocated_id(std::string* id) {
  if (id != nullptr) {
    
  } else {
    
  }
  id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), id,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.Gb28181Config.Id)
}

// string ServerIp = 2;
inline void Gb28181Config::clear_serverip() {
  serverip_.ClearToEmpty();
}
inline const std::string& Gb28181Config::serverip() const {
  // @@protoc_insertion_point(field_get:protomsg.Gb28181Config.ServerIp)
  return _internal_serverip();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Gb28181Config::set_serverip(ArgT0&& arg0, ArgT... args) {
 
 serverip_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.Gb28181Config.ServerIp)
}
inline std::string* Gb28181Config::mutable_serverip() {
  std::string* _s = _internal_mutable_serverip();
  // @@protoc_insertion_point(field_mutable:protomsg.Gb28181Config.ServerIp)
  return _s;
}
inline const std::string& Gb28181Config::_internal_serverip() const {
  return serverip_.Get();
}
inline void Gb28181Config::_internal_set_serverip(const std::string& value) {
  
  serverip_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Gb28181Config::_internal_mutable_serverip() {
  
  return serverip_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Gb28181Config::release_serverip() {
  // @@protoc_insertion_point(field_release:protomsg.Gb28181Config.ServerIp)
  return serverip_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Gb28181Config::set_allocated_serverip(std::string* serverip) {
  if (serverip != nullptr) {
    
  } else {
    
  }
  serverip_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), serverip,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.Gb28181Config.ServerIp)
}

// string ServerPort = 3;
inline void Gb28181Config::clear_serverport() {
  serverport_.ClearToEmpty();
}
inline const std::string& Gb28181Config::serverport() const {
  // @@protoc_insertion_point(field_get:protomsg.Gb28181Config.ServerPort)
  return _internal_serverport();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Gb28181Config::set_serverport(ArgT0&& arg0, ArgT... args) {
 
 serverport_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.Gb28181Config.ServerPort)
}
inline std::string* Gb28181Config::mutable_serverport() {
  std::string* _s = _internal_mutable_serverport();
  // @@protoc_insertion_point(field_mutable:protomsg.Gb28181Config.ServerPort)
  return _s;
}
inline const std::string& Gb28181Config::_internal_serverport() const {
  return serverport_.Get();
}
inline void Gb28181Config::_internal_set_serverport(const std::string& value) {
  
  serverport_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Gb28181Config::_internal_mutable_serverport() {
  
  return serverport_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Gb28181Config::release_serverport() {
  // @@protoc_insertion_point(field_release:protomsg.Gb28181Config.ServerPort)
  return serverport_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Gb28181Config::set_allocated_serverport(std::string* serverport) {
  if (serverport != nullptr) {
    
  } else {
    
  }
  serverport_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), serverport,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.Gb28181Config.ServerPort)
}

// string PublicId = 4;
inline void Gb28181Config::clear_publicid() {
  publicid_.ClearToEmpty();
}
inline const std::string& Gb28181Config::publicid() const {
  // @@protoc_insertion_point(field_get:protomsg.Gb28181Config.PublicId)
  return _internal_publicid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Gb28181Config::set_publicid(ArgT0&& arg0, ArgT... args) {
 
 publicid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.Gb28181Config.PublicId)
}
inline std::string* Gb28181Config::mutable_publicid() {
  std::string* _s = _internal_mutable_publicid();
  // @@protoc_insertion_point(field_mutable:protomsg.Gb28181Config.PublicId)
  return _s;
}
inline const std::string& Gb28181Config::_internal_publicid() const {
  return publicid_.Get();
}
inline void Gb28181Config::_internal_set_publicid(const std::string& value) {
  
  publicid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Gb28181Config::_internal_mutable_publicid() {
  
  return publicid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Gb28181Config::release_publicid() {
  // @@protoc_insertion_point(field_release:protomsg.Gb28181Config.PublicId)
  return publicid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Gb28181Config::set_allocated_publicid(std::string* publicid) {
  if (publicid != nullptr) {
    
  } else {
    
  }
  publicid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), publicid,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.Gb28181Config.PublicId)
}

// string GbServerPort = 5;
inline void Gb28181Config::clear_gbserverport() {
  gbserverport_.ClearToEmpty();
}
inline const std::string& Gb28181Config::gbserverport() const {
  // @@protoc_insertion_point(field_get:protomsg.Gb28181Config.GbServerPort)
  return _internal_gbserverport();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Gb28181Config::set_gbserverport(ArgT0&& arg0, ArgT... args) {
 
 gbserverport_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.Gb28181Config.GbServerPort)
}
inline std::string* Gb28181Config::mutable_gbserverport() {
  std::string* _s = _internal_mutable_gbserverport();
  // @@protoc_insertion_point(field_mutable:protomsg.Gb28181Config.GbServerPort)
  return _s;
}
inline const std::string& Gb28181Config::_internal_gbserverport() const {
  return gbserverport_.Get();
}
inline void Gb28181Config::_internal_set_gbserverport(const std::string& value) {
  
  gbserverport_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Gb28181Config::_internal_mutable_gbserverport() {
  
  return gbserverport_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Gb28181Config::release_gbserverport() {
  // @@protoc_insertion_point(field_release:protomsg.Gb28181Config.GbServerPort)
  return gbserverport_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Gb28181Config::set_allocated_gbserverport(std::string* gbserverport) {
  if (gbserverport != nullptr) {
    
  } else {
    
  }
  gbserverport_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), gbserverport,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.Gb28181Config.GbServerPort)
}

// bool IsAuth = 6;
inline void Gb28181Config::clear_isauth() {
  isauth_ = false;
}
inline bool Gb28181Config::_internal_isauth() const {
  return isauth_;
}
inline bool Gb28181Config::isauth() const {
  // @@protoc_insertion_point(field_get:protomsg.Gb28181Config.IsAuth)
  return _internal_isauth();
}
inline void Gb28181Config::_internal_set_isauth(bool value) {
  
  isauth_ = value;
}
inline void Gb28181Config::set_isauth(bool value) {
  _internal_set_isauth(value);
  // @@protoc_insertion_point(field_set:protomsg.Gb28181Config.IsAuth)
}

// string Password = 7;
inline void Gb28181Config::clear_password() {
  password_.ClearToEmpty();
}
inline const std::string& Gb28181Config::password() const {
  // @@protoc_insertion_point(field_get:protomsg.Gb28181Config.Password)
  return _internal_password();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Gb28181Config::set_password(ArgT0&& arg0, ArgT... args) {
 
 password_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.Gb28181Config.Password)
}
inline std::string* Gb28181Config::mutable_password() {
  std::string* _s = _internal_mutable_password();
  // @@protoc_insertion_point(field_mutable:protomsg.Gb28181Config.Password)
  return _s;
}
inline const std::string& Gb28181Config::_internal_password() const {
  return password_.Get();
}
inline void Gb28181Config::_internal_set_password(const std::string& value) {
  
  password_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Gb28181Config::_internal_mutable_password() {
  
  return password_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Gb28181Config::release_password() {
  // @@protoc_insertion_point(field_release:protomsg.Gb28181Config.Password)
  return password_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Gb28181Config::set_allocated_password(std::string* password) {
  if (password != nullptr) {
    
  } else {
    
  }
  password_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), password,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.Gb28181Config.Password)
}

// string UpdateTime = 8;
inline void Gb28181Config::clear_updatetime() {
  updatetime_.ClearToEmpty();
}
inline const std::string& Gb28181Config::updatetime() const {
  // @@protoc_insertion_point(field_get:protomsg.Gb28181Config.UpdateTime)
  return _internal_updatetime();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Gb28181Config::set_updatetime(ArgT0&& arg0, ArgT... args) {
 
 updatetime_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:protomsg.Gb28181Config.UpdateTime)
}
inline std::string* Gb28181Config::mutable_updatetime() {
  std::string* _s = _internal_mutable_updatetime();
  // @@protoc_insertion_point(field_mutable:protomsg.Gb28181Config.UpdateTime)
  return _s;
}
inline const std::string& Gb28181Config::_internal_updatetime() const {
  return updatetime_.Get();
}
inline void Gb28181Config::_internal_set_updatetime(const std::string& value) {
  
  updatetime_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Gb28181Config::_internal_mutable_updatetime() {
  
  return updatetime_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Gb28181Config::release_updatetime() {
  // @@protoc_insertion_point(field_release:protomsg.Gb28181Config.UpdateTime)
  return updatetime_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Gb28181Config::set_allocated_updatetime(std::string* updatetime) {
  if (updatetime != nullptr) {
    
  } else {
    
  }
  updatetime_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), updatetime,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:protomsg.Gb28181Config.UpdateTime)
}

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace protomsg

// @@protoc_insertion_point(global_scope)

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