text: // Generated by the protocol buffer compiler.  DO NOT EDIT!
  // source: proto/cluster.proto
  
  #ifndef GOOGLE_PROTOBUF_INCLUDED_proto_2fcluster_2eproto
  #define GOOGLE_PROTOBUF_INCLUDED_proto_2fcluster_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 3017001 < 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_proto_2fcluster_2eproto
  PROTOBUF_NAMESPACE_OPEN
  namespace internal {
  class AnyMetadata;
  }  // namespace internal
  PROTOBUF_NAMESPACE_CLOSE
  
  // Internal implementation detail -- do not use these members.
  struct TableStruct_proto_2fcluster_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[4]
      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_proto_2fcluster_2eproto;
  namespace clusterpb {
  class GateInstead;
  struct GateInsteadDefaultTypeInternal;
  extern GateInsteadDefaultTypeInternal _GateInstead_default_instance_;
  class HandshakeAck;
  struct HandshakeAckDefaultTypeInternal;
  extern HandshakeAckDefaultTypeInternal _HandshakeAck_default_instance_;
  class HandshakeRequest;
  struct HandshakeRequestDefaultTypeInternal;
  extern HandshakeRequestDefaultTypeInternal _HandshakeRequest_default_instance_;
  class HandshakeResponse;
  struct HandshakeResponseDefaultTypeInternal;
  extern HandshakeResponseDefaultTypeInternal _HandshakeResponse_default_instance_;
  }  // namespace clusterpb
  PROTOBUF_NAMESPACE_OPEN
  template<> ::clusterpb::GateInstead* Arena::CreateMaybeMessage<::clusterpb::GateInstead>(Arena*);
  template<> ::clusterpb::HandshakeAck* Arena::CreateMaybeMessage<::clusterpb::HandshakeAck>(Arena*);
  template<> ::clusterpb::HandshakeRequest* Arena::CreateMaybeMessage<::clusterpb::HandshakeRequest>(Arena*);
  template<> ::clusterpb::HandshakeResponse* Arena::CreateMaybeMessage<::clusterpb::HandshakeResponse>(Arena*);
  PROTOBUF_NAMESPACE_CLOSE
  namespace clusterpb {
  
  // ===================================================================
  
  class HandshakeRequest final :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:clusterpb.HandshakeRequest) */ {
   public:
    inline HandshakeRequest() : HandshakeRequest(nullptr) {}
    ~HandshakeRequest() override;
    explicit constexpr HandshakeRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  
    HandshakeRequest(const HandshakeRequest& from);
    HandshakeRequest(HandshakeRequest&& from) noexcept
      : HandshakeRequest() {
      *this = ::std::move(from);
    }
  
    inline HandshakeRequest& operator=(const HandshakeRequest& from) {
      CopyFrom(from);
      return *this;
    }
    inline HandshakeRequest& operator=(HandshakeRequest&& 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 HandshakeRequest& default_instance() {
      return *internal_default_instance();
    }
    static inline const HandshakeRequest* internal_default_instance() {
      return reinterpret_cast<const HandshakeRequest*>(
                 &_HandshakeRequest_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      0;
  
    friend void swap(HandshakeRequest& a, HandshakeRequest& b) {
      a.Swap(&b);
    }
    inline void Swap(HandshakeRequest* other) {
      if (other == this) return;
      if (GetOwningArena() == other->GetOwningArena()) {
        InternalSwap(other);
      } else {
        ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
      }
    }
    void UnsafeArenaSwap(HandshakeRequest* other) {
      if (other == this) return;
      GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline HandshakeRequest* New() const final {
      return new HandshakeRequest();
    }
  
    HandshakeRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<HandshakeRequest>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const HandshakeRequest& from);
    void MergeFrom(const HandshakeRequest& from);
    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(HandshakeRequest* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "clusterpb.HandshakeRequest";
    }
    protected:
    explicit HandshakeRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
    private:
    static void ArenaDtor(void* object);
    inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
    public:
  
    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kNodeNameFieldNumber = 1,
      kHostFieldNumber = 2,
      kVersionFieldNumber = 4,
      kPortFieldNumber = 3,
    };
    // string NodeName = 1;
    void clear_nodename();
    const std::string& nodename() const;
    template <typename ArgT0 = const std::string&, typename... ArgT>
    void set_nodename(ArgT0&& arg0, ArgT... args);
    std::string* mutable_nodename();
    PROTOBUF_FUTURE_MUST_USE_RESULT std::string* release_nodename();
    void set_allocated_nodename(std::string* nodename);
    private:
    const std::string& _internal_nodename() const;
    inline PROTOBUF_ALWAYS_INLINE void _internal_set_nodename(const std::string& value);
    std::string* _internal_mutable_nodename();
    public:
  
    // string Host = 2;
    void clear_host();
    const std::string& host() const;
    template <typename ArgT0 = const std::string&, typename... ArgT>
    void set_host(ArgT0&& arg0, ArgT... args);
    std::string* mutable_host();
    PROTOBUF_FUTURE_MUST_USE_RESULT std::string* release_host();
    void set_allocated_host(std::string* host);
    private:
    const std::string& _internal_host() const;
    inline PROTOBUF_ALWAYS_INLINE void _internal_set_host(const std::string& value);
    std::string* _internal_mutable_host();
    public:
  
    // int64 Version = 4;
    void clear_version();
    ::PROTOBUF_NAMESPACE_ID::int64 version() const;
    void set_version(::PROTOBUF_NAMESPACE_ID::int64 value);
    private:
    ::PROTOBUF_NAMESPACE_ID::int64 _internal_version() const;
    void _internal_set_version(::PROTOBUF_NAMESPACE_ID::int64 value);
    public:
  
    // int32 Port = 3;
    void clear_port();
    ::PROTOBUF_NAMESPACE_ID::int32 port() const;
    void set_port(::PROTOBUF_NAMESPACE_ID::int32 value);
    private:
    ::PROTOBUF_NAMESPACE_ID::int32 _internal_port() const;
    void _internal_set_port(::PROTOBUF_NAMESPACE_ID::int32 value);
    public:
  
    // @@protoc_insertion_point(class_scope:clusterpb.HandshakeRequest)
   private:
    class _Internal;
  
    template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
    typedef void InternalArenaConstructable_;
    typedef void DestructorSkippable_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr nodename_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr host_;
    ::PROTOBUF_NAMESPACE_ID::int64 version_;
    ::PROTOBUF_NAMESPACE_ID::int32 port_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_proto_2fcluster_2eproto;
  };
  // -------------------------------------------------------------------
  
  class HandshakeResponse final :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:clusterpb.HandshakeResponse) */ {
   public:
    inline HandshakeResponse() : HandshakeResponse(nullptr) {}
    ~HandshakeResponse() override;
    explicit constexpr HandshakeResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  
    HandshakeResponse(const HandshakeResponse& from);
    HandshakeResponse(HandshakeResponse&& from) noexcept
      : HandshakeResponse() {
      *this = ::std::move(from);
    }
  
    inline HandshakeResponse& operator=(const HandshakeResponse& from) {
      CopyFrom(from);
      return *this;
    }
    inline HandshakeResponse& operator=(HandshakeResponse&& 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 HandshakeResponse& default_instance() {
      return *internal_default_instance();
    }
    static inline const HandshakeResponse* internal_default_instance() {
      return reinterpret_cast<const HandshakeResponse*>(
                 &_HandshakeResponse_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      1;
  
    friend void swap(HandshakeResponse& a, HandshakeResponse& b) {
      a.Swap(&b);
    }
    inline void Swap(HandshakeResponse* other) {
      if (other == this) return;
      if (GetOwningArena() == other->GetOwningArena()) {
        InternalSwap(other);
      } else {
        ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
      }
    }
    void UnsafeArenaSwap(HandshakeResponse* other) {
      if (other == this) return;
      GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline HandshakeResponse* New() const final {
      return new HandshakeResponse();
    }
  
    HandshakeResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<HandshakeResponse>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const HandshakeResponse& from);
    void MergeFrom(const HandshakeResponse& from);
    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(HandshakeResponse* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "clusterpb.HandshakeResponse";
    }
    protected:
    explicit HandshakeResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
    private:
    static void ArenaDtor(void* object);
    inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
    public:
  
    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kCodeFieldNumber = 1,
    };
    // int32 Code = 1;
    void clear_code();
    ::PROTOBUF_NAMESPACE_ID::int32 code() const;
    void set_code(::PROTOBUF_NAMESPACE_ID::int32 value);
    private:
    ::PROTOBUF_NAMESPACE_ID::int32 _internal_code() const;
    void _internal_set_code(::PROTOBUF_NAMESPACE_ID::int32 value);
    public:
  
    // @@protoc_insertion_point(class_scope:clusterpb.HandshakeResponse)
   private:
    class _Internal;
  
    template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
    typedef void InternalArenaConstructable_;
    typedef void DestructorSkippable_;
    ::PROTOBUF_NAMESPACE_ID::int32 code_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_proto_2fcluster_2eproto;
  };
  // -------------------------------------------------------------------
  
  class HandshakeAck final :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:clusterpb.HandshakeAck) */ {
   public:
    inline HandshakeAck() : HandshakeAck(nullptr) {}
    ~HandshakeAck() override;
    explicit constexpr HandshakeAck(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  
    HandshakeAck(const HandshakeAck& from);
    HandshakeAck(HandshakeAck&& from) noexcept
      : HandshakeAck() {
      *this = ::std::move(from);
    }
  
    inline HandshakeAck& operator=(const HandshakeAck& from) {
      CopyFrom(from);
      return *this;
    }
    inline HandshakeAck& operator=(HandshakeAck&& 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 HandshakeAck& default_instance() {
      return *internal_default_instance();
    }
    static inline const HandshakeAck* internal_default_instance() {
      return reinterpret_cast<const HandshakeAck*>(
                 &_HandshakeAck_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      2;
  
    friend void swap(HandshakeAck& a, HandshakeAck& b) {
      a.Swap(&b);
    }
    inline void Swap(HandshakeAck* other) {
      if (other == this) return;
      if (GetOwningArena() == other->GetOwningArena()) {
        InternalSwap(other);
      } else {
        ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
      }
    }
    void UnsafeArenaSwap(HandshakeAck* other) {
      if (other == this) return;
      GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline HandshakeAck* New() const final {
      return new HandshakeAck();
    }
  
    HandshakeAck* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<HandshakeAck>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const HandshakeAck& from);
    void MergeFrom(const HandshakeAck& from);
    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(HandshakeAck* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "clusterpb.HandshakeAck";
    }
    protected:
    explicit HandshakeAck(::PROTOBUF_NAMESPACE_ID::Arena* arena);
    private:
    static void ArenaDtor(void* object);
    inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
    public:
  
    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    // @@protoc_insertion_point(class_scope:clusterpb.HandshakeAck)
   private:
    class _Internal;
  
    template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
    typedef void InternalArenaConstructable_;
    typedef void DestructorSkippable_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_proto_2fcluster_2eproto;
  };
  // -------------------------------------------------------------------
  
  class GateInstead final :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:clusterpb.GateInstead) */ {
   public:
    inline GateInstead() : GateInstead(nullptr) {}
    ~GateInstead() override;
    explicit constexpr GateInstead(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  
    GateInstead(const GateInstead& from);
    GateInstead(GateInstead&& from) noexcept
      : GateInstead() {
      *this = ::std::move(from);
    }
  
    inline GateInstead& operator=(const GateInstead& from) {
      CopyFrom(from);
      return *this;
    }
    inline GateInstead& operator=(GateInstead&& 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 GateInstead& default_instance() {
      return *internal_default_instance();
    }
    static inline const GateInstead* internal_default_instance() {
      return reinterpret_cast<const GateInstead*>(
                 &_GateInstead_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      3;
  
    friend void swap(GateInstead& a, GateInstead& b) {
      a.Swap(&b);
    }
    inline void Swap(GateInstead* other) {
      if (other == this) return;
      if (GetOwningArena() == other->GetOwningArena()) {
        InternalSwap(other);
      } else {
        ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
      }
    }
    void UnsafeArenaSwap(GateInstead* other) {
      if (other == this) return;
      GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline GateInstead* New() const final {
      return new GateInstead();
    }
  
    GateInstead* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<GateInstead>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const GateInstead& from);
    void MergeFrom(const GateInstead& from);
    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(GateInstead* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "clusterpb.GateInstead";
    }
    protected:
    explicit GateInstead(::PROTOBUF_NAMESPACE_ID::Arena* arena);
    private:
    static void ArenaDtor(void* object);
    inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
    public:
  
    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kUserIdFieldNumber = 1,
    };
    // uint64 userId = 1;
    void clear_userid();
    ::PROTOBUF_NAMESPACE_ID::uint64 userid() const;
    void set_userid(::PROTOBUF_NAMESPACE_ID::uint64 value);
    private:
    ::PROTOBUF_NAMESPACE_ID::uint64 _internal_userid() const;
    void _internal_set_userid(::PROTOBUF_NAMESPACE_ID::uint64 value);
    public:
  
    // @@protoc_insertion_point(class_scope:clusterpb.GateInstead)
   private:
    class _Internal;
  
    template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
    typedef void InternalArenaConstructable_;
    typedef void DestructorSkippable_;
    ::PROTOBUF_NAMESPACE_ID::uint64 userid_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_proto_2fcluster_2eproto;
  };
  // ===================================================================
  
  
  // ===================================================================
  
  #ifdef __GNUC__
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wstrict-aliasing"
  #endif  // __GNUC__
  // HandshakeRequest
  
  // string NodeName = 1;
  inline void HandshakeRequest::clear_nodename() {
    nodename_.ClearToEmpty();
  }
  inline const std::string& HandshakeRequest::nodename() const {
    // @@protoc_insertion_point(field_get:clusterpb.HandshakeRequest.NodeName)
    return _internal_nodename();
  }
  template <typename ArgT0, typename... ArgT>
  inline PROTOBUF_ALWAYS_INLINE
  void HandshakeRequest::set_nodename(ArgT0&& arg0, ArgT... args) {
   
   nodename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
    // @@protoc_insertion_point(field_set:clusterpb.HandshakeRequest.NodeName)
  }
  inline std::string* HandshakeRequest::mutable_nodename() {
    // @@protoc_insertion_point(field_mutable:clusterpb.HandshakeRequest.NodeName)
    return _internal_mutable_nodename();
  }
  inline const std::string& HandshakeRequest::_internal_nodename() const {
    return nodename_.Get();
  }
  inline void HandshakeRequest::_internal_set_nodename(const std::string& value) {
    
    nodename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
  }
  inline std::string* HandshakeRequest::_internal_mutable_nodename() {
    
    return nodename_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
  }
  inline std::string* HandshakeRequest::release_nodename() {
    // @@protoc_insertion_point(field_release:clusterpb.HandshakeRequest.NodeName)
    return nodename_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
  }
  inline void HandshakeRequest::set_allocated_nodename(std::string* nodename) {
    if (nodename != nullptr) {
      
    } else {
      
    }
    nodename_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), nodename,
        GetArenaForAllocation());
    // @@protoc_insertion_point(field_set_allocated:clusterpb.HandshakeRequest.NodeName)
  }
  
  // string Host = 2;
  inline void HandshakeRequest::clear_host() {
    host_.ClearToEmpty();
  }
  inline const std::string& HandshakeRequest::host() const {
    // @@protoc_insertion_point(field_get:clusterpb.HandshakeRequest.Host)
    return _internal_host();
  }
  template <typename ArgT0, typename... ArgT>
  inline PROTOBUF_ALWAYS_INLINE
  void HandshakeRequest::set_host(ArgT0&& arg0, ArgT... args) {
   
   host_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
    // @@protoc_insertion_point(field_set:clusterpb.HandshakeRequest.Host)
  }
  inline std::string* HandshakeRequest::mutable_host() {
    // @@protoc_insertion_point(field_mutable:clusterpb.HandshakeRequest.Host)
    return _internal_mutable_host();
  }
  inline const std::string& HandshakeRequest::_internal_host() const {
    return host_.Get();
  }
  inline void HandshakeRequest::_internal_set_host(const std::string& value) {
    
    host_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
  }
  inline std::string* HandshakeRequest::_internal_mutable_host() {
    
    return host_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
  }
  inline std::string* HandshakeRequest::release_host() {
    // @@protoc_insertion_point(field_release:clusterpb.HandshakeRequest.Host)
    return host_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
  }
  inline void HandshakeRequest::set_allocated_host(std::string* host) {
    if (host != nullptr) {
      
    } else {
      
    }
    host_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), host,
        GetArenaForAllocation());
    // @@protoc_insertion_point(field_set_allocated:clusterpb.HandshakeRequest.Host)
  }
  
  // int32 Port = 3;
  inline void HandshakeRequest::clear_port() {
    port_ = 0;
  }
  inline ::PROTOBUF_NAMESPACE_ID::int32 HandshakeRequest::_internal_port() const {
    return port_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::int32 HandshakeRequest::port() const {
    // @@protoc_insertion_point(field_get:clusterpb.HandshakeRequest.Port)
    return _internal_port();
  }
  inline void HandshakeRequest::_internal_set_port(::PROTOBUF_NAMESPACE_ID::int32 value) {
    
    port_ = value;
  }
  inline void HandshakeRequest::set_port(::PROTOBUF_NAMESPACE_ID::int32 value) {
    _internal_set_port(value);
    // @@protoc_insertion_point(field_set:clusterpb.HandshakeRequest.Port)
  }
  
  // int64 Version = 4;
  inline void HandshakeRequest::clear_version() {
    version_ = int64_t{0};
  }
  inline ::PROTOBUF_NAMESPACE_ID::int64 HandshakeRequest::_internal_version() const {
    return version_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::int64 HandshakeRequest::version() const {
    // @@protoc_insertion_point(field_get:clusterpb.HandshakeRequest.Version)
    return _internal_version();
  }
  inline void HandshakeRequest::_internal_set_version(::PROTOBUF_NAMESPACE_ID::int64 value) {
    
    version_ = value;
  }
  inline void HandshakeRequest::set_version(::PROTOBUF_NAMESPACE_ID::int64 value) {
    _internal_set_version(value);
    // @@protoc_insertion_point(field_set:clusterpb.HandshakeRequest.Version)
  }
  
  // -------------------------------------------------------------------
  
  // HandshakeResponse
  
  // int32 Code = 1;
  inline void HandshakeResponse::clear_code() {
    code_ = 0;
  }
  inline ::PROTOBUF_NAMESPACE_ID::int32 HandshakeResponse::_internal_code() const {
    return code_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::int32 HandshakeResponse::code() const {
    // @@protoc_insertion_point(field_get:clusterpb.HandshakeResponse.Code)
    return _internal_code();
  }
  inline void HandshakeResponse::_internal_set_code(::PROTOBUF_NAMESPACE_ID::int32 value) {
    
    code_ = value;
  }
  inline void HandshakeResponse::set_code(::PROTOBUF_NAMESPACE_ID::int32 value) {
    _internal_set_code(value);
    // @@protoc_insertion_point(field_set:clusterpb.HandshakeResponse.Code)
  }
  
  // -------------------------------------------------------------------
  
  // HandshakeAck
  
  // -------------------------------------------------------------------
  
  // GateInstead
  
  // uint64 userId = 1;
  inline void GateInstead::clear_userid() {
    userid_ = uint64_t{0u};
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint64 GateInstead::_internal_userid() const {
    return userid_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint64 GateInstead::userid() const {
    // @@protoc_insertion_point(field_get:clusterpb.GateInstead.userId)
    return _internal_userid();
  }
  inline void GateInstead::_internal_set_userid(::PROTOBUF_NAMESPACE_ID::uint64 value) {
    
    userid_ = value;
  }
  inline void GateInstead::set_userid(::PROTOBUF_NAMESPACE_ID::uint64 value) {
    _internal_set_userid(value);
    // @@protoc_insertion_point(field_set:clusterpb.GateInstead.userId)
  }
  
  #ifdef __GNUC__
    #pragma GCC diagnostic pop
  #endif  // __GNUC__
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  
  // @@protoc_insertion_point(namespace_scope)
  
  }  // namespace clusterpb
  
  // @@protoc_insertion_point(global_scope)
  
  #include <google/protobuf/port_undef.inc>
  #endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_proto_2fcluster_2eproto
  