text: // Generated by the protocol buffer compiler.  DO NOT EDIT!
  // source: ClientNamenodeProtocol.proto
  
  #ifndef PROTOBUF_INCLUDED_ClientNamenodeProtocol_2eproto
  #define PROTOBUF_INCLUDED_ClientNamenodeProtocol_2eproto
  
  #include <string>
  
  #include <google/protobuf/stubs/common.h>
  
  #if GOOGLE_PROTOBUF_VERSION < 3006001
  #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 3006001 < GOOGLE_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/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/inlined_string_field.h>
  #include <google/protobuf/metadata.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>
  #include "HdfsProtocol.pb.h"
  // @@protoc_insertion_point(includes)
  #define PROTOBUF_INTERNAL_EXPORT_protobuf_ClientNamenodeProtocol_2eproto 
  
  namespace protobuf_ClientNamenodeProtocol_2eproto {
  // Internal implementation detail -- do not use these members.
  struct TableStruct {
    static const ::google::protobuf::internal::ParseTableField entries[];
    static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
    static const ::google::protobuf::internal::ParseTable schema[14];
    static const ::google::protobuf::internal::FieldMetadata field_metadata[];
    static const ::google::protobuf::internal::SerializationTable serialization_table[];
    static const ::google::protobuf::uint32 offsets[];
  };
  void AddDescriptors();
  }  // namespace protobuf_ClientNamenodeProtocol_2eproto
  namespace cn {
  namespace edu {
  namespace cn {
  namespace tsinghua {
  namespace hdfs {
  namespace protocol {
  class CdRequestProto;
  class CdRequestProtoDefaultTypeInternal;
  extern CdRequestProtoDefaultTypeInternal _CdRequestProto_default_instance_;
  class CdResponseProto;
  class CdResponseProtoDefaultTypeInternal;
  extern CdResponseProtoDefaultTypeInternal _CdResponseProto_default_instance_;
  class GetRequestProto;
  class GetRequestProtoDefaultTypeInternal;
  extern GetRequestProtoDefaultTypeInternal _GetRequestProto_default_instance_;
  class GetResponseProto;
  class GetResponseProtoDefaultTypeInternal;
  extern GetResponseProtoDefaultTypeInternal _GetResponseProto_default_instance_;
  class InitRequestProto;
  class InitRequestProtoDefaultTypeInternal;
  extern InitRequestProtoDefaultTypeInternal _InitRequestProto_default_instance_;
  class InitResponseProto;
  class InitResponseProtoDefaultTypeInternal;
  extern InitResponseProtoDefaultTypeInternal _InitResponseProto_default_instance_;
  class LsRequestProto;
  class LsRequestProtoDefaultTypeInternal;
  extern LsRequestProtoDefaultTypeInternal _LsRequestProto_default_instance_;
  class LsResponseProto;
  class LsResponseProtoDefaultTypeInternal;
  extern LsResponseProtoDefaultTypeInternal _LsResponseProto_default_instance_;
  class MkdirRequestProto;
  class MkdirRequestProtoDefaultTypeInternal;
  extern MkdirRequestProtoDefaultTypeInternal _MkdirRequestProto_default_instance_;
  class MkdirResponseProto;
  class MkdirResponseProtoDefaultTypeInternal;
  extern MkdirResponseProtoDefaultTypeInternal _MkdirResponseProto_default_instance_;
  class PutRequestProto;
  class PutRequestProtoDefaultTypeInternal;
  extern PutRequestProtoDefaultTypeInternal _PutRequestProto_default_instance_;
  class PutResponseProto;
  class PutResponseProtoDefaultTypeInternal;
  extern PutResponseProtoDefaultTypeInternal _PutResponseProto_default_instance_;
  class RmRequestProto;
  class RmRequestProtoDefaultTypeInternal;
  extern RmRequestProtoDefaultTypeInternal _RmRequestProto_default_instance_;
  class RmResponseProto;
  class RmResponseProtoDefaultTypeInternal;
  extern RmResponseProtoDefaultTypeInternal _RmResponseProto_default_instance_;
  }  // namespace protocol
  }  // namespace hdfs
  }  // namespace tsinghua
  }  // namespace cn
  }  // namespace edu
  }  // namespace cn
  namespace google {
  namespace protobuf {
  template<> ::cn::edu::cn::tsinghua::hdfs::protocol::CdRequestProto* Arena::CreateMaybeMessage<::cn::edu::cn::tsinghua::hdfs::protocol::CdRequestProto>(Arena*);
  template<> ::cn::edu::cn::tsinghua::hdfs::protocol::CdResponseProto* Arena::CreateMaybeMessage<::cn::edu::cn::tsinghua::hdfs::protocol::CdResponseProto>(Arena*);
  template<> ::cn::edu::cn::tsinghua::hdfs::protocol::GetRequestProto* Arena::CreateMaybeMessage<::cn::edu::cn::tsinghua::hdfs::protocol::GetRequestProto>(Arena*);
  template<> ::cn::edu::cn::tsinghua::hdfs::protocol::GetResponseProto* Arena::CreateMaybeMessage<::cn::edu::cn::tsinghua::hdfs::protocol::GetResponseProto>(Arena*);
  template<> ::cn::edu::cn::tsinghua::hdfs::protocol::InitRequestProto* Arena::CreateMaybeMessage<::cn::edu::cn::tsinghua::hdfs::protocol::InitRequestProto>(Arena*);
  template<> ::cn::edu::cn::tsinghua::hdfs::protocol::InitResponseProto* Arena::CreateMaybeMessage<::cn::edu::cn::tsinghua::hdfs::protocol::InitResponseProto>(Arena*);
  template<> ::cn::edu::cn::tsinghua::hdfs::protocol::LsRequestProto* Arena::CreateMaybeMessage<::cn::edu::cn::tsinghua::hdfs::protocol::LsRequestProto>(Arena*);
  template<> ::cn::edu::cn::tsinghua::hdfs::protocol::LsResponseProto* Arena::CreateMaybeMessage<::cn::edu::cn::tsinghua::hdfs::protocol::LsResponseProto>(Arena*);
  template<> ::cn::edu::cn::tsinghua::hdfs::protocol::MkdirRequestProto* Arena::CreateMaybeMessage<::cn::edu::cn::tsinghua::hdfs::protocol::MkdirRequestProto>(Arena*);
  template<> ::cn::edu::cn::tsinghua::hdfs::protocol::MkdirResponseProto* Arena::CreateMaybeMessage<::cn::edu::cn::tsinghua::hdfs::protocol::MkdirResponseProto>(Arena*);
  template<> ::cn::edu::cn::tsinghua::hdfs::protocol::PutRequestProto* Arena::CreateMaybeMessage<::cn::edu::cn::tsinghua::hdfs::protocol::PutRequestProto>(Arena*);
  template<> ::cn::edu::cn::tsinghua::hdfs::protocol::PutResponseProto* Arena::CreateMaybeMessage<::cn::edu::cn::tsinghua::hdfs::protocol::PutResponseProto>(Arena*);
  template<> ::cn::edu::cn::tsinghua::hdfs::protocol::RmRequestProto* Arena::CreateMaybeMessage<::cn::edu::cn::tsinghua::hdfs::protocol::RmRequestProto>(Arena*);
  template<> ::cn::edu::cn::tsinghua::hdfs::protocol::RmResponseProto* Arena::CreateMaybeMessage<::cn::edu::cn::tsinghua::hdfs::protocol::RmResponseProto>(Arena*);
  }  // namespace protobuf
  }  // namespace google
  namespace cn {
  namespace edu {
  namespace cn {
  namespace tsinghua {
  namespace hdfs {
  namespace protocol {
  
  // ===================================================================
  
  class InitRequestProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:cn.edu.cn.tsinghua.hdfs.protocol.InitRequestProto) */ {
   public:
    InitRequestProto();
    virtual ~InitRequestProto();
  
    InitRequestProto(const InitRequestProto& from);
  
    inline InitRequestProto& operator=(const InitRequestProto& from) {
      CopyFrom(from);
      return *this;
    }
    #if LANG_CXX11
    InitRequestProto(InitRequestProto&& from) noexcept
      : InitRequestProto() {
      *this = ::std::move(from);
    }
  
    inline InitRequestProto& operator=(InitRequestProto&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
    #endif
    static const ::google::protobuf::Descriptor* descriptor();
    static const InitRequestProto& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const InitRequestProto* internal_default_instance() {
      return reinterpret_cast<const InitRequestProto*>(
                 &_InitRequestProto_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      0;
  
    void Swap(InitRequestProto* other);
    friend void swap(InitRequestProto& a, InitRequestProto& b) {
      a.Swap(&b);
    }
  
    // implements Message ----------------------------------------------
  
    inline InitRequestProto* New() const final {
      return CreateMaybeMessage<InitRequestProto>(NULL);
    }
  
    InitRequestProto* New(::google::protobuf::Arena* arena) const final {
      return CreateMaybeMessage<InitRequestProto>(arena);
    }
    void CopyFrom(const ::google::protobuf::Message& from) final;
    void MergeFrom(const ::google::protobuf::Message& from) final;
    void CopyFrom(const InitRequestProto& from);
    void MergeFrom(const InitRequestProto& from);
    void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input) final;
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const final;
    ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
        bool deterministic, ::google::protobuf::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(InitRequestProto* other);
    private:
    inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
      return NULL;
    }
    inline void* MaybeArenaPtr() const {
      return NULL;
    }
    public:
  
    ::google::protobuf::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    // @@protoc_insertion_point(class_scope:cn.edu.cn.tsinghua.hdfs.protocol.InitRequestProto)
   private:
  
    ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    friend struct ::protobuf_ClientNamenodeProtocol_2eproto::TableStruct;
  };
  // -------------------------------------------------------------------
  
  class InitResponseProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:cn.edu.cn.tsinghua.hdfs.protocol.InitResponseProto) */ {
   public:
    InitResponseProto();
    virtual ~InitResponseProto();
  
    InitResponseProto(const InitResponseProto& from);
  
    inline InitResponseProto& operator=(const InitResponseProto& from) {
      CopyFrom(from);
      return *this;
    }
    #if LANG_CXX11
    InitResponseProto(InitResponseProto&& from) noexcept
      : InitResponseProto() {
      *this = ::std::move(from);
    }
  
    inline InitResponseProto& operator=(InitResponseProto&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
    #endif
    static const ::google::protobuf::Descriptor* descriptor();
    static const InitResponseProto& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const InitResponseProto* internal_default_instance() {
      return reinterpret_cast<const InitResponseProto*>(
                 &_InitResponseProto_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      1;
  
    void Swap(InitResponseProto* other);
    friend void swap(InitResponseProto& a, InitResponseProto& b) {
      a.Swap(&b);
    }
  
    // implements Message ----------------------------------------------
  
    inline InitResponseProto* New() const final {
      return CreateMaybeMessage<InitResponseProto>(NULL);
    }
  
    InitResponseProto* New(::google::protobuf::Arena* arena) const final {
      return CreateMaybeMessage<InitResponseProto>(arena);
    }
    void CopyFrom(const ::google::protobuf::Message& from) final;
    void MergeFrom(const ::google::protobuf::Message& from) final;
    void CopyFrom(const InitResponseProto& from);
    void MergeFrom(const InitResponseProto& from);
    void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input) final;
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const final;
    ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
        bool deterministic, ::google::protobuf::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(InitResponseProto* other);
    private:
    inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
      return NULL;
    }
    inline void* MaybeArenaPtr() const {
      return NULL;
    }
    public:
  
    ::google::protobuf::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    // .cn.edu.cn.tsinghua.hdfs.protocol.PathProto path = 1;
    bool has_path() const;
    void clear_path();
    static const int kPathFieldNumber = 1;
    private:
    const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& _internal_path() const;
    public:
    const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& path() const;
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* release_path();
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* mutable_path();
    void set_allocated_path(::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* path);
  
    // @@protoc_insertion_point(class_scope:cn.edu.cn.tsinghua.hdfs.protocol.InitResponseProto)
   private:
  
    ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* path_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    friend struct ::protobuf_ClientNamenodeProtocol_2eproto::TableStruct;
  };
  // -------------------------------------------------------------------
  
  class CdRequestProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:cn.edu.cn.tsinghua.hdfs.protocol.CdRequestProto) */ {
   public:
    CdRequestProto();
    virtual ~CdRequestProto();
  
    CdRequestProto(const CdRequestProto& from);
  
    inline CdRequestProto& operator=(const CdRequestProto& from) {
      CopyFrom(from);
      return *this;
    }
    #if LANG_CXX11
    CdRequestProto(CdRequestProto&& from) noexcept
      : CdRequestProto() {
      *this = ::std::move(from);
    }
  
    inline CdRequestProto& operator=(CdRequestProto&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
    #endif
    static const ::google::protobuf::Descriptor* descriptor();
    static const CdRequestProto& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const CdRequestProto* internal_default_instance() {
      return reinterpret_cast<const CdRequestProto*>(
                 &_CdRequestProto_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      2;
  
    void Swap(CdRequestProto* other);
    friend void swap(CdRequestProto& a, CdRequestProto& b) {
      a.Swap(&b);
    }
  
    // implements Message ----------------------------------------------
  
    inline CdRequestProto* New() const final {
      return CreateMaybeMessage<CdRequestProto>(NULL);
    }
  
    CdRequestProto* New(::google::protobuf::Arena* arena) const final {
      return CreateMaybeMessage<CdRequestProto>(arena);
    }
    void CopyFrom(const ::google::protobuf::Message& from) final;
    void MergeFrom(const ::google::protobuf::Message& from) final;
    void CopyFrom(const CdRequestProto& from);
    void MergeFrom(const CdRequestProto& from);
    void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input) final;
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const final;
    ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
        bool deterministic, ::google::protobuf::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(CdRequestProto* other);
    private:
    inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
      return NULL;
    }
    inline void* MaybeArenaPtr() const {
      return NULL;
    }
    public:
  
    ::google::protobuf::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    // .cn.edu.cn.tsinghua.hdfs.protocol.PathProto path = 1;
    bool has_path() const;
    void clear_path();
    static const int kPathFieldNumber = 1;
    private:
    const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& _internal_path() const;
    public:
    const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& path() const;
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* release_path();
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* mutable_path();
    void set_allocated_path(::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* path);
  
    // @@protoc_insertion_point(class_scope:cn.edu.cn.tsinghua.hdfs.protocol.CdRequestProto)
   private:
  
    ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* path_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    friend struct ::protobuf_ClientNamenodeProtocol_2eproto::TableStruct;
  };
  // -------------------------------------------------------------------
  
  class CdResponseProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:cn.edu.cn.tsinghua.hdfs.protocol.CdResponseProto) */ {
   public:
    CdResponseProto();
    virtual ~CdResponseProto();
  
    CdResponseProto(const CdResponseProto& from);
  
    inline CdResponseProto& operator=(const CdResponseProto& from) {
      CopyFrom(from);
      return *this;
    }
    #if LANG_CXX11
    CdResponseProto(CdResponseProto&& from) noexcept
      : CdResponseProto() {
      *this = ::std::move(from);
    }
  
    inline CdResponseProto& operator=(CdResponseProto&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
    #endif
    static const ::google::protobuf::Descriptor* descriptor();
    static const CdResponseProto& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const CdResponseProto* internal_default_instance() {
      return reinterpret_cast<const CdResponseProto*>(
                 &_CdResponseProto_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      3;
  
    void Swap(CdResponseProto* other);
    friend void swap(CdResponseProto& a, CdResponseProto& b) {
      a.Swap(&b);
    }
  
    // implements Message ----------------------------------------------
  
    inline CdResponseProto* New() const final {
      return CreateMaybeMessage<CdResponseProto>(NULL);
    }
  
    CdResponseProto* New(::google::protobuf::Arena* arena) const final {
      return CreateMaybeMessage<CdResponseProto>(arena);
    }
    void CopyFrom(const ::google::protobuf::Message& from) final;
    void MergeFrom(const ::google::protobuf::Message& from) final;
    void CopyFrom(const CdResponseProto& from);
    void MergeFrom(const CdResponseProto& from);
    void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input) final;
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const final;
    ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
        bool deterministic, ::google::protobuf::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(CdResponseProto* other);
    private:
    inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
      return NULL;
    }
    inline void* MaybeArenaPtr() const {
      return NULL;
    }
    public:
  
    ::google::protobuf::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    // .cn.edu.cn.tsinghua.hdfs.protocol.PathProto path = 1;
    bool has_path() const;
    void clear_path();
    static const int kPathFieldNumber = 1;
    private:
    const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& _internal_path() const;
    public:
    const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& path() const;
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* release_path();
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* mutable_path();
    void set_allocated_path(::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* path);
  
    // bool isSuccessful = 2;
    void clear_issuccessful();
    static const int kIsSuccessfulFieldNumber = 2;
    bool issuccessful() const;
    void set_issuccessful(bool value);
  
    // @@protoc_insertion_point(class_scope:cn.edu.cn.tsinghua.hdfs.protocol.CdResponseProto)
   private:
  
    ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* path_;
    bool issuccessful_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    friend struct ::protobuf_ClientNamenodeProtocol_2eproto::TableStruct;
  };
  // -------------------------------------------------------------------
  
  class LsRequestProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:cn.edu.cn.tsinghua.hdfs.protocol.LsRequestProto) */ {
   public:
    LsRequestProto();
    virtual ~LsRequestProto();
  
    LsRequestProto(const LsRequestProto& from);
  
    inline LsRequestProto& operator=(const LsRequestProto& from) {
      CopyFrom(from);
      return *this;
    }
    #if LANG_CXX11
    LsRequestProto(LsRequestProto&& from) noexcept
      : LsRequestProto() {
      *this = ::std::move(from);
    }
  
    inline LsRequestProto& operator=(LsRequestProto&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
    #endif
    static const ::google::protobuf::Descriptor* descriptor();
    static const LsRequestProto& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const LsRequestProto* internal_default_instance() {
      return reinterpret_cast<const LsRequestProto*>(
                 &_LsRequestProto_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      4;
  
    void Swap(LsRequestProto* other);
    friend void swap(LsRequestProto& a, LsRequestProto& b) {
      a.Swap(&b);
    }
  
    // implements Message ----------------------------------------------
  
    inline LsRequestProto* New() const final {
      return CreateMaybeMessage<LsRequestProto>(NULL);
    }
  
    LsRequestProto* New(::google::protobuf::Arena* arena) const final {
      return CreateMaybeMessage<LsRequestProto>(arena);
    }
    void CopyFrom(const ::google::protobuf::Message& from) final;
    void MergeFrom(const ::google::protobuf::Message& from) final;
    void CopyFrom(const LsRequestProto& from);
    void MergeFrom(const LsRequestProto& from);
    void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input) final;
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const final;
    ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
        bool deterministic, ::google::protobuf::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(LsRequestProto* other);
    private:
    inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
      return NULL;
    }
    inline void* MaybeArenaPtr() const {
      return NULL;
    }
    public:
  
    ::google::protobuf::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    // .cn.edu.cn.tsinghua.hdfs.protocol.PathProto path = 1;
    bool has_path() const;
    void clear_path();
    static const int kPathFieldNumber = 1;
    private:
    const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& _internal_path() const;
    public:
    const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& path() const;
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* release_path();
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* mutable_path();
    void set_allocated_path(::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* path);
  
    // @@protoc_insertion_point(class_scope:cn.edu.cn.tsinghua.hdfs.protocol.LsRequestProto)
   private:
  
    ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* path_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    friend struct ::protobuf_ClientNamenodeProtocol_2eproto::TableStruct;
  };
  // -------------------------------------------------------------------
  
  class LsResponseProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:cn.edu.cn.tsinghua.hdfs.protocol.LsResponseProto) */ {
   public:
    LsResponseProto();
    virtual ~LsResponseProto();
  
    LsResponseProto(const LsResponseProto& from);
  
    inline LsResponseProto& operator=(const LsResponseProto& from) {
      CopyFrom(from);
      return *this;
    }
    #if LANG_CXX11
    LsResponseProto(LsResponseProto&& from) noexcept
      : LsResponseProto() {
      *this = ::std::move(from);
    }
  
    inline LsResponseProto& operator=(LsResponseProto&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
    #endif
    static const ::google::protobuf::Descriptor* descriptor();
    static const LsResponseProto& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const LsResponseProto* internal_default_instance() {
      return reinterpret_cast<const LsResponseProto*>(
                 &_LsResponseProto_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      5;
  
    void Swap(LsResponseProto* other);
    friend void swap(LsResponseProto& a, LsResponseProto& b) {
      a.Swap(&b);
    }
  
    // implements Message ----------------------------------------------
  
    inline LsResponseProto* New() const final {
      return CreateMaybeMessage<LsResponseProto>(NULL);
    }
  
    LsResponseProto* New(::google::protobuf::Arena* arena) const final {
      return CreateMaybeMessage<LsResponseProto>(arena);
    }
    void CopyFrom(const ::google::protobuf::Message& from) final;
    void MergeFrom(const ::google::protobuf::Message& from) final;
    void CopyFrom(const LsResponseProto& from);
    void MergeFrom(const LsResponseProto& from);
    void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input) final;
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const final;
    ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
        bool deterministic, ::google::protobuf::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(LsResponseProto* other);
    private:
    inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
      return NULL;
    }
    inline void* MaybeArenaPtr() const {
      return NULL;
    }
    public:
  
    ::google::protobuf::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    // repeated .cn.edu.cn.tsinghua.hdfs.protocol.PathProto path = 1;
    int path_size() const;
    void clear_path();
    static const int kPathFieldNumber = 1;
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* mutable_path(int index);
    ::google::protobuf::RepeatedPtrField< ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto >*
        mutable_path();
    const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& path(int index) const;
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* add_path();
    const ::google::protobuf::RepeatedPtrField< ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto >&
        path() const;
  
    // @@protoc_insertion_point(class_scope:cn.edu.cn.tsinghua.hdfs.protocol.LsResponseProto)
   private:
  
    ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
    ::google::protobuf::RepeatedPtrField< ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto > path_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    friend struct ::protobuf_ClientNamenodeProtocol_2eproto::TableStruct;
  };
  // -------------------------------------------------------------------
  
  class MkdirRequestProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:cn.edu.cn.tsinghua.hdfs.protocol.MkdirRequestProto) */ {
   public:
    MkdirRequestProto();
    virtual ~MkdirRequestProto();
  
    MkdirRequestProto(const MkdirRequestProto& from);
  
    inline MkdirRequestProto& operator=(const MkdirRequestProto& from) {
      CopyFrom(from);
      return *this;
    }
    #if LANG_CXX11
    MkdirRequestProto(MkdirRequestProto&& from) noexcept
      : MkdirRequestProto() {
      *this = ::std::move(from);
    }
  
    inline MkdirRequestProto& operator=(MkdirRequestProto&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
    #endif
    static const ::google::protobuf::Descriptor* descriptor();
    static const MkdirRequestProto& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const MkdirRequestProto* internal_default_instance() {
      return reinterpret_cast<const MkdirRequestProto*>(
                 &_MkdirRequestProto_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      6;
  
    void Swap(MkdirRequestProto* other);
    friend void swap(MkdirRequestProto& a, MkdirRequestProto& b) {
      a.Swap(&b);
    }
  
    // implements Message ----------------------------------------------
  
    inline MkdirRequestProto* New() const final {
      return CreateMaybeMessage<MkdirRequestProto>(NULL);
    }
  
    MkdirRequestProto* New(::google::protobuf::Arena* arena) const final {
      return CreateMaybeMessage<MkdirRequestProto>(arena);
    }
    void CopyFrom(const ::google::protobuf::Message& from) final;
    void MergeFrom(const ::google::protobuf::Message& from) final;
    void CopyFrom(const MkdirRequestProto& from);
    void MergeFrom(const MkdirRequestProto& from);
    void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input) final;
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const final;
    ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
        bool deterministic, ::google::protobuf::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(MkdirRequestProto* other);
    private:
    inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
      return NULL;
    }
    inline void* MaybeArenaPtr() const {
      return NULL;
    }
    public:
  
    ::google::protobuf::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    // repeated .cn.edu.cn.tsinghua.hdfs.protocol.PathProto path = 1;
    int path_size() const;
    void clear_path();
    static const int kPathFieldNumber = 1;
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* mutable_path(int index);
    ::google::protobuf::RepeatedPtrField< ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto >*
        mutable_path();
    const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& path(int index) const;
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* add_path();
    const ::google::protobuf::RepeatedPtrField< ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto >&
        path() const;
  
    // @@protoc_insertion_point(class_scope:cn.edu.cn.tsinghua.hdfs.protocol.MkdirRequestProto)
   private:
  
    ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
    ::google::protobuf::RepeatedPtrField< ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto > path_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    friend struct ::protobuf_ClientNamenodeProtocol_2eproto::TableStruct;
  };
  // -------------------------------------------------------------------
  
  class MkdirResponseProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:cn.edu.cn.tsinghua.hdfs.protocol.MkdirResponseProto) */ {
   public:
    MkdirResponseProto();
    virtual ~MkdirResponseProto();
  
    MkdirResponseProto(const MkdirResponseProto& from);
  
    inline MkdirResponseProto& operator=(const MkdirResponseProto& from) {
      CopyFrom(from);
      return *this;
    }
    #if LANG_CXX11
    MkdirResponseProto(MkdirResponseProto&& from) noexcept
      : MkdirResponseProto() {
      *this = ::std::move(from);
    }
  
    inline MkdirResponseProto& operator=(MkdirResponseProto&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
    #endif
    static const ::google::protobuf::Descriptor* descriptor();
    static const MkdirResponseProto& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const MkdirResponseProto* internal_default_instance() {
      return reinterpret_cast<const MkdirResponseProto*>(
                 &_MkdirResponseProto_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      7;
  
    void Swap(MkdirResponseProto* other);
    friend void swap(MkdirResponseProto& a, MkdirResponseProto& b) {
      a.Swap(&b);
    }
  
    // implements Message ----------------------------------------------
  
    inline MkdirResponseProto* New() const final {
      return CreateMaybeMessage<MkdirResponseProto>(NULL);
    }
  
    MkdirResponseProto* New(::google::protobuf::Arena* arena) const final {
      return CreateMaybeMessage<MkdirResponseProto>(arena);
    }
    void CopyFrom(const ::google::protobuf::Message& from) final;
    void MergeFrom(const ::google::protobuf::Message& from) final;
    void CopyFrom(const MkdirResponseProto& from);
    void MergeFrom(const MkdirResponseProto& from);
    void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input) final;
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const final;
    ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
        bool deterministic, ::google::protobuf::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(MkdirResponseProto* other);
    private:
    inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
      return NULL;
    }
    inline void* MaybeArenaPtr() const {
      return NULL;
    }
    public:
  
    ::google::protobuf::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    // @@protoc_insertion_point(class_scope:cn.edu.cn.tsinghua.hdfs.protocol.MkdirResponseProto)
   private:
  
    ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    friend struct ::protobuf_ClientNamenodeProtocol_2eproto::TableStruct;
  };
  // -------------------------------------------------------------------
  
  class GetRequestProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:cn.edu.cn.tsinghua.hdfs.protocol.GetRequestProto) */ {
   public:
    GetRequestProto();
    virtual ~GetRequestProto();
  
    GetRequestProto(const GetRequestProto& from);
  
    inline GetRequestProto& operator=(const GetRequestProto& from) {
      CopyFrom(from);
      return *this;
    }
    #if LANG_CXX11
    GetRequestProto(GetRequestProto&& from) noexcept
      : GetRequestProto() {
      *this = ::std::move(from);
    }
  
    inline GetRequestProto& operator=(GetRequestProto&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
    #endif
    static const ::google::protobuf::Descriptor* descriptor();
    static const GetRequestProto& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const GetRequestProto* internal_default_instance() {
      return reinterpret_cast<const GetRequestProto*>(
                 &_GetRequestProto_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      8;
  
    void Swap(GetRequestProto* other);
    friend void swap(GetRequestProto& a, GetRequestProto& b) {
      a.Swap(&b);
    }
  
    // implements Message ----------------------------------------------
  
    inline GetRequestProto* New() const final {
      return CreateMaybeMessage<GetRequestProto>(NULL);
    }
  
    GetRequestProto* New(::google::protobuf::Arena* arena) const final {
      return CreateMaybeMessage<GetRequestProto>(arena);
    }
    void CopyFrom(const ::google::protobuf::Message& from) final;
    void MergeFrom(const ::google::protobuf::Message& from) final;
    void CopyFrom(const GetRequestProto& from);
    void MergeFrom(const GetRequestProto& from);
    void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input) final;
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const final;
    ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
        bool deterministic, ::google::protobuf::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(GetRequestProto* other);
    private:
    inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
      return NULL;
    }
    inline void* MaybeArenaPtr() const {
      return NULL;
    }
    public:
  
    ::google::protobuf::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    // .cn.edu.cn.tsinghua.hdfs.protocol.PathProto path = 1;
    bool has_path() const;
    void clear_path();
    static const int kPathFieldNumber = 1;
    private:
    const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& _internal_path() const;
    public:
    const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& path() const;
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* release_path();
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* mutable_path();
    void set_allocated_path(::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* path);
  
    // @@protoc_insertion_point(class_scope:cn.edu.cn.tsinghua.hdfs.protocol.GetRequestProto)
   private:
  
    ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* path_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    friend struct ::protobuf_ClientNamenodeProtocol_2eproto::TableStruct;
  };
  // -------------------------------------------------------------------
  
  class GetResponseProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:cn.edu.cn.tsinghua.hdfs.protocol.GetResponseProto) */ {
   public:
    GetResponseProto();
    virtual ~GetResponseProto();
  
    GetResponseProto(const GetResponseProto& from);
  
    inline GetResponseProto& operator=(const GetResponseProto& from) {
      CopyFrom(from);
      return *this;
    }
    #if LANG_CXX11
    GetResponseProto(GetResponseProto&& from) noexcept
      : GetResponseProto() {
      *this = ::std::move(from);
    }
  
    inline GetResponseProto& operator=(GetResponseProto&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
    #endif
    static const ::google::protobuf::Descriptor* descriptor();
    static const GetResponseProto& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const GetResponseProto* internal_default_instance() {
      return reinterpret_cast<const GetResponseProto*>(
                 &_GetResponseProto_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      9;
  
    void Swap(GetResponseProto* other);
    friend void swap(GetResponseProto& a, GetResponseProto& b) {
      a.Swap(&b);
    }
  
    // implements Message ----------------------------------------------
  
    inline GetResponseProto* New() const final {
      return CreateMaybeMessage<GetResponseProto>(NULL);
    }
  
    GetResponseProto* New(::google::protobuf::Arena* arena) const final {
      return CreateMaybeMessage<GetResponseProto>(arena);
    }
    void CopyFrom(const ::google::protobuf::Message& from) final;
    void MergeFrom(const ::google::protobuf::Message& from) final;
    void CopyFrom(const GetResponseProto& from);
    void MergeFrom(const GetResponseProto& from);
    void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input) final;
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const final;
    ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
        bool deterministic, ::google::protobuf::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(GetResponseProto* other);
    private:
    inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
      return NULL;
    }
    inline void* MaybeArenaPtr() const {
      return NULL;
    }
    public:
  
    ::google::protobuf::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    // repeated .cn.edu.cn.tsinghua.hdfs.protocol.BlockProto blocks = 1;
    int blocks_size() const;
    void clear_blocks();
    static const int kBlocksFieldNumber = 1;
    ::cn::edu::cn::tsinghua::hdfs::protocol::BlockProto* mutable_blocks(int index);
    ::google::protobuf::RepeatedPtrField< ::cn::edu::cn::tsinghua::hdfs::protocol::BlockProto >*
        mutable_blocks();
    const ::cn::edu::cn::tsinghua::hdfs::protocol::BlockProto& blocks(int index) const;
    ::cn::edu::cn::tsinghua::hdfs::protocol::BlockProto* add_blocks();
    const ::google::protobuf::RepeatedPtrField< ::cn::edu::cn::tsinghua::hdfs::protocol::BlockProto >&
        blocks() const;
  
    // @@protoc_insertion_point(class_scope:cn.edu.cn.tsinghua.hdfs.protocol.GetResponseProto)
   private:
  
    ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
    ::google::protobuf::RepeatedPtrField< ::cn::edu::cn::tsinghua::hdfs::protocol::BlockProto > blocks_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    friend struct ::protobuf_ClientNamenodeProtocol_2eproto::TableStruct;
  };
  // -------------------------------------------------------------------
  
  class PutRequestProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:cn.edu.cn.tsinghua.hdfs.protocol.PutRequestProto) */ {
   public:
    PutRequestProto();
    virtual ~PutRequestProto();
  
    PutRequestProto(const PutRequestProto& from);
  
    inline PutRequestProto& operator=(const PutRequestProto& from) {
      CopyFrom(from);
      return *this;
    }
    #if LANG_CXX11
    PutRequestProto(PutRequestProto&& from) noexcept
      : PutRequestProto() {
      *this = ::std::move(from);
    }
  
    inline PutRequestProto& operator=(PutRequestProto&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
    #endif
    static const ::google::protobuf::Descriptor* descriptor();
    static const PutRequestProto& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const PutRequestProto* internal_default_instance() {
      return reinterpret_cast<const PutRequestProto*>(
                 &_PutRequestProto_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      10;
  
    void Swap(PutRequestProto* other);
    friend void swap(PutRequestProto& a, PutRequestProto& b) {
      a.Swap(&b);
    }
  
    // implements Message ----------------------------------------------
  
    inline PutRequestProto* New() const final {
      return CreateMaybeMessage<PutRequestProto>(NULL);
    }
  
    PutRequestProto* New(::google::protobuf::Arena* arena) const final {
      return CreateMaybeMessage<PutRequestProto>(arena);
    }
    void CopyFrom(const ::google::protobuf::Message& from) final;
    void MergeFrom(const ::google::protobuf::Message& from) final;
    void CopyFrom(const PutRequestProto& from);
    void MergeFrom(const PutRequestProto& from);
    void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input) final;
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const final;
    ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
        bool deterministic, ::google::protobuf::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(PutRequestProto* other);
    private:
    inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
      return NULL;
    }
    inline void* MaybeArenaPtr() const {
      return NULL;
    }
    public:
  
    ::google::protobuf::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    // .cn.edu.cn.tsinghua.hdfs.protocol.PathProto path = 1;
    bool has_path() const;
    void clear_path();
    static const int kPathFieldNumber = 1;
    private:
    const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& _internal_path() const;
    public:
    const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& path() const;
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* release_path();
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* mutable_path();
    void set_allocated_path(::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* path);
  
    // uint64 length = 2;
    void clear_length();
    static const int kLengthFieldNumber = 2;
    ::google::protobuf::uint64 length() const;
    void set_length(::google::protobuf::uint64 value);
  
    // @@protoc_insertion_point(class_scope:cn.edu.cn.tsinghua.hdfs.protocol.PutRequestProto)
   private:
  
    ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* path_;
    ::google::protobuf::uint64 length_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    friend struct ::protobuf_ClientNamenodeProtocol_2eproto::TableStruct;
  };
  // -------------------------------------------------------------------
  
  class PutResponseProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:cn.edu.cn.tsinghua.hdfs.protocol.PutResponseProto) */ {
   public:
    PutResponseProto();
    virtual ~PutResponseProto();
  
    PutResponseProto(const PutResponseProto& from);
  
    inline PutResponseProto& operator=(const PutResponseProto& from) {
      CopyFrom(from);
      return *this;
    }
    #if LANG_CXX11
    PutResponseProto(PutResponseProto&& from) noexcept
      : PutResponseProto() {
      *this = ::std::move(from);
    }
  
    inline PutResponseProto& operator=(PutResponseProto&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
    #endif
    static const ::google::protobuf::Descriptor* descriptor();
    static const PutResponseProto& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const PutResponseProto* internal_default_instance() {
      return reinterpret_cast<const PutResponseProto*>(
                 &_PutResponseProto_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      11;
  
    void Swap(PutResponseProto* other);
    friend void swap(PutResponseProto& a, PutResponseProto& b) {
      a.Swap(&b);
    }
  
    // implements Message ----------------------------------------------
  
    inline PutResponseProto* New() const final {
      return CreateMaybeMessage<PutResponseProto>(NULL);
    }
  
    PutResponseProto* New(::google::protobuf::Arena* arena) const final {
      return CreateMaybeMessage<PutResponseProto>(arena);
    }
    void CopyFrom(const ::google::protobuf::Message& from) final;
    void MergeFrom(const ::google::protobuf::Message& from) final;
    void CopyFrom(const PutResponseProto& from);
    void MergeFrom(const PutResponseProto& from);
    void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input) final;
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const final;
    ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
        bool deterministic, ::google::protobuf::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(PutResponseProto* other);
    private:
    inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
      return NULL;
    }
    inline void* MaybeArenaPtr() const {
      return NULL;
    }
    public:
  
    ::google::protobuf::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    // repeated .cn.edu.cn.tsinghua.hdfs.protocol.BlockProto blocks = 1;
    int blocks_size() const;
    void clear_blocks();
    static const int kBlocksFieldNumber = 1;
    ::cn::edu::cn::tsinghua::hdfs::protocol::BlockProto* mutable_blocks(int index);
    ::google::protobuf::RepeatedPtrField< ::cn::edu::cn::tsinghua::hdfs::protocol::BlockProto >*
        mutable_blocks();
    const ::cn::edu::cn::tsinghua::hdfs::protocol::BlockProto& blocks(int index) const;
    ::cn::edu::cn::tsinghua::hdfs::protocol::BlockProto* add_blocks();
    const ::google::protobuf::RepeatedPtrField< ::cn::edu::cn::tsinghua::hdfs::protocol::BlockProto >&
        blocks() const;
  
    // @@protoc_insertion_point(class_scope:cn.edu.cn.tsinghua.hdfs.protocol.PutResponseProto)
   private:
  
    ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
    ::google::protobuf::RepeatedPtrField< ::cn::edu::cn::tsinghua::hdfs::protocol::BlockProto > blocks_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    friend struct ::protobuf_ClientNamenodeProtocol_2eproto::TableStruct;
  };
  // -------------------------------------------------------------------
  
  class RmRequestProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:cn.edu.cn.tsinghua.hdfs.protocol.RmRequestProto) */ {
   public:
    RmRequestProto();
    virtual ~RmRequestProto();
  
    RmRequestProto(const RmRequestProto& from);
  
    inline RmRequestProto& operator=(const RmRequestProto& from) {
      CopyFrom(from);
      return *this;
    }
    #if LANG_CXX11
    RmRequestProto(RmRequestProto&& from) noexcept
      : RmRequestProto() {
      *this = ::std::move(from);
    }
  
    inline RmRequestProto& operator=(RmRequestProto&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
    #endif
    static const ::google::protobuf::Descriptor* descriptor();
    static const RmRequestProto& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const RmRequestProto* internal_default_instance() {
      return reinterpret_cast<const RmRequestProto*>(
                 &_RmRequestProto_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      12;
  
    void Swap(RmRequestProto* other);
    friend void swap(RmRequestProto& a, RmRequestProto& b) {
      a.Swap(&b);
    }
  
    // implements Message ----------------------------------------------
  
    inline RmRequestProto* New() const final {
      return CreateMaybeMessage<RmRequestProto>(NULL);
    }
  
    RmRequestProto* New(::google::protobuf::Arena* arena) const final {
      return CreateMaybeMessage<RmRequestProto>(arena);
    }
    void CopyFrom(const ::google::protobuf::Message& from) final;
    void MergeFrom(const ::google::protobuf::Message& from) final;
    void CopyFrom(const RmRequestProto& from);
    void MergeFrom(const RmRequestProto& from);
    void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input) final;
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const final;
    ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
        bool deterministic, ::google::protobuf::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(RmRequestProto* other);
    private:
    inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
      return NULL;
    }
    inline void* MaybeArenaPtr() const {
      return NULL;
    }
    public:
  
    ::google::protobuf::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    // repeated .cn.edu.cn.tsinghua.hdfs.protocol.PathProto path = 1;
    int path_size() const;
    void clear_path();
    static const int kPathFieldNumber = 1;
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* mutable_path(int index);
    ::google::protobuf::RepeatedPtrField< ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto >*
        mutable_path();
    const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& path(int index) const;
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* add_path();
    const ::google::protobuf::RepeatedPtrField< ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto >&
        path() const;
  
    // @@protoc_insertion_point(class_scope:cn.edu.cn.tsinghua.hdfs.protocol.RmRequestProto)
   private:
  
    ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
    ::google::protobuf::RepeatedPtrField< ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto > path_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    friend struct ::protobuf_ClientNamenodeProtocol_2eproto::TableStruct;
  };
  // -------------------------------------------------------------------
  
  class RmResponseProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:cn.edu.cn.tsinghua.hdfs.protocol.RmResponseProto) */ {
   public:
    RmResponseProto();
    virtual ~RmResponseProto();
  
    RmResponseProto(const RmResponseProto& from);
  
    inline RmResponseProto& operator=(const RmResponseProto& from) {
      CopyFrom(from);
      return *this;
    }
    #if LANG_CXX11
    RmResponseProto(RmResponseProto&& from) noexcept
      : RmResponseProto() {
      *this = ::std::move(from);
    }
  
    inline RmResponseProto& operator=(RmResponseProto&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
    #endif
    static const ::google::protobuf::Descriptor* descriptor();
    static const RmResponseProto& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const RmResponseProto* internal_default_instance() {
      return reinterpret_cast<const RmResponseProto*>(
                 &_RmResponseProto_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      13;
  
    void Swap(RmResponseProto* other);
    friend void swap(RmResponseProto& a, RmResponseProto& b) {
      a.Swap(&b);
    }
  
    // implements Message ----------------------------------------------
  
    inline RmResponseProto* New() const final {
      return CreateMaybeMessage<RmResponseProto>(NULL);
    }
  
    RmResponseProto* New(::google::protobuf::Arena* arena) const final {
      return CreateMaybeMessage<RmResponseProto>(arena);
    }
    void CopyFrom(const ::google::protobuf::Message& from) final;
    void MergeFrom(const ::google::protobuf::Message& from) final;
    void CopyFrom(const RmResponseProto& from);
    void MergeFrom(const RmResponseProto& from);
    void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input) final;
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const final;
    ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
        bool deterministic, ::google::protobuf::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(RmResponseProto* other);
    private:
    inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
      return NULL;
    }
    inline void* MaybeArenaPtr() const {
      return NULL;
    }
    public:
  
    ::google::protobuf::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    // bool isSuccessful = 1;
    void clear_issuccessful();
    static const int kIsSuccessfulFieldNumber = 1;
    bool issuccessful() const;
    void set_issuccessful(bool value);
  
    // @@protoc_insertion_point(class_scope:cn.edu.cn.tsinghua.hdfs.protocol.RmResponseProto)
   private:
  
    ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
    bool issuccessful_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    friend struct ::protobuf_ClientNamenodeProtocol_2eproto::TableStruct;
  };
  // ===================================================================
  
  
  // ===================================================================
  
  #ifdef __GNUC__
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wstrict-aliasing"
  #endif  // __GNUC__
  // InitRequestProto
  
  // -------------------------------------------------------------------
  
  // InitResponseProto
  
  // .cn.edu.cn.tsinghua.hdfs.protocol.PathProto path = 1;
  inline bool InitResponseProto::has_path() const {
    return this != internal_default_instance() && path_ != NULL;
  }
  inline const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& InitResponseProto::_internal_path() const {
    return *path_;
  }
  inline const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& InitResponseProto::path() const {
    const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* p = path_;
    // @@protoc_insertion_point(field_get:cn.edu.cn.tsinghua.hdfs.protocol.InitResponseProto.path)
    return p != NULL ? *p : *reinterpret_cast<const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto*>(
        &::cn::edu::cn::tsinghua::hdfs::protocol::_PathProto_default_instance_);
  }
  inline ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* InitResponseProto::release_path() {
    // @@protoc_insertion_point(field_release:cn.edu.cn.tsinghua.hdfs.protocol.InitResponseProto.path)
    
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* temp = path_;
    path_ = NULL;
    return temp;
  }
  inline ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* InitResponseProto::mutable_path() {
    
    if (path_ == NULL) {
      auto* p = CreateMaybeMessage<::cn::edu::cn::tsinghua::hdfs::protocol::PathProto>(GetArenaNoVirtual());
      path_ = p;
    }
    // @@protoc_insertion_point(field_mutable:cn.edu.cn.tsinghua.hdfs.protocol.InitResponseProto.path)
    return path_;
  }
  inline void InitResponseProto::set_allocated_path(::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* path) {
    ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
    if (message_arena == NULL) {
      delete reinterpret_cast< ::google::protobuf::MessageLite*>(path_);
    }
    if (path) {
      ::google::protobuf::Arena* submessage_arena = NULL;
      if (message_arena != submessage_arena) {
        path = ::google::protobuf::internal::GetOwnedMessage(
            message_arena, path, submessage_arena);
      }
      
    } else {
      
    }
    path_ = path;
    // @@protoc_insertion_point(field_set_allocated:cn.edu.cn.tsinghua.hdfs.protocol.InitResponseProto.path)
  }
  
  // -------------------------------------------------------------------
  
  // CdRequestProto
  
  // .cn.edu.cn.tsinghua.hdfs.protocol.PathProto path = 1;
  inline bool CdRequestProto::has_path() const {
    return this != internal_default_instance() && path_ != NULL;
  }
  inline const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& CdRequestProto::_internal_path() const {
    return *path_;
  }
  inline const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& CdRequestProto::path() const {
    const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* p = path_;
    // @@protoc_insertion_point(field_get:cn.edu.cn.tsinghua.hdfs.protocol.CdRequestProto.path)
    return p != NULL ? *p : *reinterpret_cast<const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto*>(
        &::cn::edu::cn::tsinghua::hdfs::protocol::_PathProto_default_instance_);
  }
  inline ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* CdRequestProto::release_path() {
    // @@protoc_insertion_point(field_release:cn.edu.cn.tsinghua.hdfs.protocol.CdRequestProto.path)
    
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* temp = path_;
    path_ = NULL;
    return temp;
  }
  inline ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* CdRequestProto::mutable_path() {
    
    if (path_ == NULL) {
      auto* p = CreateMaybeMessage<::cn::edu::cn::tsinghua::hdfs::protocol::PathProto>(GetArenaNoVirtual());
      path_ = p;
    }
    // @@protoc_insertion_point(field_mutable:cn.edu.cn.tsinghua.hdfs.protocol.CdRequestProto.path)
    return path_;
  }
  inline void CdRequestProto::set_allocated_path(::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* path) {
    ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
    if (message_arena == NULL) {
      delete reinterpret_cast< ::google::protobuf::MessageLite*>(path_);
    }
    if (path) {
      ::google::protobuf::Arena* submessage_arena = NULL;
      if (message_arena != submessage_arena) {
        path = ::google::protobuf::internal::GetOwnedMessage(
            message_arena, path, submessage_arena);
      }
      
    } else {
      
    }
    path_ = path;
    // @@protoc_insertion_point(field_set_allocated:cn.edu.cn.tsinghua.hdfs.protocol.CdRequestProto.path)
  }
  
  // -------------------------------------------------------------------
  
  // CdResponseProto
  
  // .cn.edu.cn.tsinghua.hdfs.protocol.PathProto path = 1;
  inline bool CdResponseProto::has_path() const {
    return this != internal_default_instance() && path_ != NULL;
  }
  inline const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& CdResponseProto::_internal_path() const {
    return *path_;
  }
  inline const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& CdResponseProto::path() const {
    const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* p = path_;
    // @@protoc_insertion_point(field_get:cn.edu.cn.tsinghua.hdfs.protocol.CdResponseProto.path)
    return p != NULL ? *p : *reinterpret_cast<const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto*>(
        &::cn::edu::cn::tsinghua::hdfs::protocol::_PathProto_default_instance_);
  }
  inline ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* CdResponseProto::release_path() {
    // @@protoc_insertion_point(field_release:cn.edu.cn.tsinghua.hdfs.protocol.CdResponseProto.path)
    
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* temp = path_;
    path_ = NULL;
    return temp;
  }
  inline ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* CdResponseProto::mutable_path() {
    
    if (path_ == NULL) {
      auto* p = CreateMaybeMessage<::cn::edu::cn::tsinghua::hdfs::protocol::PathProto>(GetArenaNoVirtual());
      path_ = p;
    }
    // @@protoc_insertion_point(field_mutable:cn.edu.cn.tsinghua.hdfs.protocol.CdResponseProto.path)
    return path_;
  }
  inline void CdResponseProto::set_allocated_path(::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* path) {
    ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
    if (message_arena == NULL) {
      delete reinterpret_cast< ::google::protobuf::MessageLite*>(path_);
    }
    if (path) {
      ::google::protobuf::Arena* submessage_arena = NULL;
      if (message_arena != submessage_arena) {
        path = ::google::protobuf::internal::GetOwnedMessage(
            message_arena, path, submessage_arena);
      }
      
    } else {
      
    }
    path_ = path;
    // @@protoc_insertion_point(field_set_allocated:cn.edu.cn.tsinghua.hdfs.protocol.CdResponseProto.path)
  }
  
  // bool isSuccessful = 2;
  inline void CdResponseProto::clear_issuccessful() {
    issuccessful_ = false;
  }
  inline bool CdResponseProto::issuccessful() const {
    // @@protoc_insertion_point(field_get:cn.edu.cn.tsinghua.hdfs.protocol.CdResponseProto.isSuccessful)
    return issuccessful_;
  }
  inline void CdResponseProto::set_issuccessful(bool value) {
    
    issuccessful_ = value;
    // @@protoc_insertion_point(field_set:cn.edu.cn.tsinghua.hdfs.protocol.CdResponseProto.isSuccessful)
  }
  
  // -------------------------------------------------------------------
  
  // LsRequestProto
  
  // .cn.edu.cn.tsinghua.hdfs.protocol.PathProto path = 1;
  inline bool LsRequestProto::has_path() const {
    return this != internal_default_instance() && path_ != NULL;
  }
  inline const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& LsRequestProto::_internal_path() const {
    return *path_;
  }
  inline const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& LsRequestProto::path() const {
    const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* p = path_;
    // @@protoc_insertion_point(field_get:cn.edu.cn.tsinghua.hdfs.protocol.LsRequestProto.path)
    return p != NULL ? *p : *reinterpret_cast<const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto*>(
        &::cn::edu::cn::tsinghua::hdfs::protocol::_PathProto_default_instance_);
  }
  inline ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* LsRequestProto::release_path() {
    // @@protoc_insertion_point(field_release:cn.edu.cn.tsinghua.hdfs.protocol.LsRequestProto.path)
    
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* temp = path_;
    path_ = NULL;
    return temp;
  }
  inline ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* LsRequestProto::mutable_path() {
    
    if (path_ == NULL) {
      auto* p = CreateMaybeMessage<::cn::edu::cn::tsinghua::hdfs::protocol::PathProto>(GetArenaNoVirtual());
      path_ = p;
    }
    // @@protoc_insertion_point(field_mutable:cn.edu.cn.tsinghua.hdfs.protocol.LsRequestProto.path)
    return path_;
  }
  inline void LsRequestProto::set_allocated_path(::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* path) {
    ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
    if (message_arena == NULL) {
      delete reinterpret_cast< ::google::protobuf::MessageLite*>(path_);
    }
    if (path) {
      ::google::protobuf::Arena* submessage_arena = NULL;
      if (message_arena != submessage_arena) {
        path = ::google::protobuf::internal::GetOwnedMessage(
            message_arena, path, submessage_arena);
      }
      
    } else {
      
    }
    path_ = path;
    // @@protoc_insertion_point(field_set_allocated:cn.edu.cn.tsinghua.hdfs.protocol.LsRequestProto.path)
  }
  
  // -------------------------------------------------------------------
  
  // LsResponseProto
  
  // repeated .cn.edu.cn.tsinghua.hdfs.protocol.PathProto path = 1;
  inline int LsResponseProto::path_size() const {
    return path_.size();
  }
  inline ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* LsResponseProto::mutable_path(int index) {
    // @@protoc_insertion_point(field_mutable:cn.edu.cn.tsinghua.hdfs.protocol.LsResponseProto.path)
    return path_.Mutable(index);
  }
  inline ::google::protobuf::RepeatedPtrField< ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto >*
  LsResponseProto::mutable_path() {
    // @@protoc_insertion_point(field_mutable_list:cn.edu.cn.tsinghua.hdfs.protocol.LsResponseProto.path)
    return &path_;
  }
  inline const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& LsResponseProto::path(int index) const {
    // @@protoc_insertion_point(field_get:cn.edu.cn.tsinghua.hdfs.protocol.LsResponseProto.path)
    return path_.Get(index);
  }
  inline ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* LsResponseProto::add_path() {
    // @@protoc_insertion_point(field_add:cn.edu.cn.tsinghua.hdfs.protocol.LsResponseProto.path)
    return path_.Add();
  }
  inline const ::google::protobuf::RepeatedPtrField< ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto >&
  LsResponseProto::path() const {
    // @@protoc_insertion_point(field_list:cn.edu.cn.tsinghua.hdfs.protocol.LsResponseProto.path)
    return path_;
  }
  
  // -------------------------------------------------------------------
  
  // MkdirRequestProto
  
  // repeated .cn.edu.cn.tsinghua.hdfs.protocol.PathProto path = 1;
  inline int MkdirRequestProto::path_size() const {
    return path_.size();
  }
  inline ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* MkdirRequestProto::mutable_path(int index) {
    // @@protoc_insertion_point(field_mutable:cn.edu.cn.tsinghua.hdfs.protocol.MkdirRequestProto.path)
    return path_.Mutable(index);
  }
  inline ::google::protobuf::RepeatedPtrField< ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto >*
  MkdirRequestProto::mutable_path() {
    // @@protoc_insertion_point(field_mutable_list:cn.edu.cn.tsinghua.hdfs.protocol.MkdirRequestProto.path)
    return &path_;
  }
  inline const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& MkdirRequestProto::path(int index) const {
    // @@protoc_insertion_point(field_get:cn.edu.cn.tsinghua.hdfs.protocol.MkdirRequestProto.path)
    return path_.Get(index);
  }
  inline ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* MkdirRequestProto::add_path() {
    // @@protoc_insertion_point(field_add:cn.edu.cn.tsinghua.hdfs.protocol.MkdirRequestProto.path)
    return path_.Add();
  }
  inline const ::google::protobuf::RepeatedPtrField< ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto >&
  MkdirRequestProto::path() const {
    // @@protoc_insertion_point(field_list:cn.edu.cn.tsinghua.hdfs.protocol.MkdirRequestProto.path)
    return path_;
  }
  
  // -------------------------------------------------------------------
  
  // MkdirResponseProto
  
  // -------------------------------------------------------------------
  
  // GetRequestProto
  
  // .cn.edu.cn.tsinghua.hdfs.protocol.PathProto path = 1;
  inline bool GetRequestProto::has_path() const {
    return this != internal_default_instance() && path_ != NULL;
  }
  inline const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& GetRequestProto::_internal_path() const {
    return *path_;
  }
  inline const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& GetRequestProto::path() const {
    const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* p = path_;
    // @@protoc_insertion_point(field_get:cn.edu.cn.tsinghua.hdfs.protocol.GetRequestProto.path)
    return p != NULL ? *p : *reinterpret_cast<const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto*>(
        &::cn::edu::cn::tsinghua::hdfs::protocol::_PathProto_default_instance_);
  }
  inline ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* GetRequestProto::release_path() {
    // @@protoc_insertion_point(field_release:cn.edu.cn.tsinghua.hdfs.protocol.GetRequestProto.path)
    
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* temp = path_;
    path_ = NULL;
    return temp;
  }
  inline ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* GetRequestProto::mutable_path() {
    
    if (path_ == NULL) {
      auto* p = CreateMaybeMessage<::cn::edu::cn::tsinghua::hdfs::protocol::PathProto>(GetArenaNoVirtual());
      path_ = p;
    }
    // @@protoc_insertion_point(field_mutable:cn.edu.cn.tsinghua.hdfs.protocol.GetRequestProto.path)
    return path_;
  }
  inline void GetRequestProto::set_allocated_path(::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* path) {
    ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
    if (message_arena == NULL) {
      delete reinterpret_cast< ::google::protobuf::MessageLite*>(path_);
    }
    if (path) {
      ::google::protobuf::Arena* submessage_arena = NULL;
      if (message_arena != submessage_arena) {
        path = ::google::protobuf::internal::GetOwnedMessage(
            message_arena, path, submessage_arena);
      }
      
    } else {
      
    }
    path_ = path;
    // @@protoc_insertion_point(field_set_allocated:cn.edu.cn.tsinghua.hdfs.protocol.GetRequestProto.path)
  }
  
  // -------------------------------------------------------------------
  
  // GetResponseProto
  
  // repeated .cn.edu.cn.tsinghua.hdfs.protocol.BlockProto blocks = 1;
  inline int GetResponseProto::blocks_size() const {
    return blocks_.size();
  }
  inline ::cn::edu::cn::tsinghua::hdfs::protocol::BlockProto* GetResponseProto::mutable_blocks(int index) {
    // @@protoc_insertion_point(field_mutable:cn.edu.cn.tsinghua.hdfs.protocol.GetResponseProto.blocks)
    return blocks_.Mutable(index);
  }
  inline ::google::protobuf::RepeatedPtrField< ::cn::edu::cn::tsinghua::hdfs::protocol::BlockProto >*
  GetResponseProto::mutable_blocks() {
    // @@protoc_insertion_point(field_mutable_list:cn.edu.cn.tsinghua.hdfs.protocol.GetResponseProto.blocks)
    return &blocks_;
  }
  inline const ::cn::edu::cn::tsinghua::hdfs::protocol::BlockProto& GetResponseProto::blocks(int index) const {
    // @@protoc_insertion_point(field_get:cn.edu.cn.tsinghua.hdfs.protocol.GetResponseProto.blocks)
    return blocks_.Get(index);
  }
  inline ::cn::edu::cn::tsinghua::hdfs::protocol::BlockProto* GetResponseProto::add_blocks() {
    // @@protoc_insertion_point(field_add:cn.edu.cn.tsinghua.hdfs.protocol.GetResponseProto.blocks)
    return blocks_.Add();
  }
  inline const ::google::protobuf::RepeatedPtrField< ::cn::edu::cn::tsinghua::hdfs::protocol::BlockProto >&
  GetResponseProto::blocks() const {
    // @@protoc_insertion_point(field_list:cn.edu.cn.tsinghua.hdfs.protocol.GetResponseProto.blocks)
    return blocks_;
  }
  
  // -------------------------------------------------------------------
  
  // PutRequestProto
  
  // .cn.edu.cn.tsinghua.hdfs.protocol.PathProto path = 1;
  inline bool PutRequestProto::has_path() const {
    return this != internal_default_instance() && path_ != NULL;
  }
  inline const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& PutRequestProto::_internal_path() const {
    return *path_;
  }
  inline const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& PutRequestProto::path() const {
    const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* p = path_;
    // @@protoc_insertion_point(field_get:cn.edu.cn.tsinghua.hdfs.protocol.PutRequestProto.path)
    return p != NULL ? *p : *reinterpret_cast<const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto*>(
        &::cn::edu::cn::tsinghua::hdfs::protocol::_PathProto_default_instance_);
  }
  inline ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* PutRequestProto::release_path() {
    // @@protoc_insertion_point(field_release:cn.edu.cn.tsinghua.hdfs.protocol.PutRequestProto.path)
    
    ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* temp = path_;
    path_ = NULL;
    return temp;
  }
  inline ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* PutRequestProto::mutable_path() {
    
    if (path_ == NULL) {
      auto* p = CreateMaybeMessage<::cn::edu::cn::tsinghua::hdfs::protocol::PathProto>(GetArenaNoVirtual());
      path_ = p;
    }
    // @@protoc_insertion_point(field_mutable:cn.edu.cn.tsinghua.hdfs.protocol.PutRequestProto.path)
    return path_;
  }
  inline void PutRequestProto::set_allocated_path(::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* path) {
    ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
    if (message_arena == NULL) {
      delete reinterpret_cast< ::google::protobuf::MessageLite*>(path_);
    }
    if (path) {
      ::google::protobuf::Arena* submessage_arena = NULL;
      if (message_arena != submessage_arena) {
        path = ::google::protobuf::internal::GetOwnedMessage(
            message_arena, path, submessage_arena);
      }
      
    } else {
      
    }
    path_ = path;
    // @@protoc_insertion_point(field_set_allocated:cn.edu.cn.tsinghua.hdfs.protocol.PutRequestProto.path)
  }
  
  // uint64 length = 2;
  inline void PutRequestProto::clear_length() {
    length_ = GOOGLE_ULONGLONG(0);
  }
  inline ::google::protobuf::uint64 PutRequestProto::length() const {
    // @@protoc_insertion_point(field_get:cn.edu.cn.tsinghua.hdfs.protocol.PutRequestProto.length)
    return length_;
  }
  inline void PutRequestProto::set_length(::google::protobuf::uint64 value) {
    
    length_ = value;
    // @@protoc_insertion_point(field_set:cn.edu.cn.tsinghua.hdfs.protocol.PutRequestProto.length)
  }
  
  // -------------------------------------------------------------------
  
  // PutResponseProto
  
  // repeated .cn.edu.cn.tsinghua.hdfs.protocol.BlockProto blocks = 1;
  inline int PutResponseProto::blocks_size() const {
    return blocks_.size();
  }
  inline ::cn::edu::cn::tsinghua::hdfs::protocol::BlockProto* PutResponseProto::mutable_blocks(int index) {
    // @@protoc_insertion_point(field_mutable:cn.edu.cn.tsinghua.hdfs.protocol.PutResponseProto.blocks)
    return blocks_.Mutable(index);
  }
  inline ::google::protobuf::RepeatedPtrField< ::cn::edu::cn::tsinghua::hdfs::protocol::BlockProto >*
  PutResponseProto::mutable_blocks() {
    // @@protoc_insertion_point(field_mutable_list:cn.edu.cn.tsinghua.hdfs.protocol.PutResponseProto.blocks)
    return &blocks_;
  }
  inline const ::cn::edu::cn::tsinghua::hdfs::protocol::BlockProto& PutResponseProto::blocks(int index) const {
    // @@protoc_insertion_point(field_get:cn.edu.cn.tsinghua.hdfs.protocol.PutResponseProto.blocks)
    return blocks_.Get(index);
  }
  inline ::cn::edu::cn::tsinghua::hdfs::protocol::BlockProto* PutResponseProto::add_blocks() {
    // @@protoc_insertion_point(field_add:cn.edu.cn.tsinghua.hdfs.protocol.PutResponseProto.blocks)
    return blocks_.Add();
  }
  inline const ::google::protobuf::RepeatedPtrField< ::cn::edu::cn::tsinghua::hdfs::protocol::BlockProto >&
  PutResponseProto::blocks() const {
    // @@protoc_insertion_point(field_list:cn.edu.cn.tsinghua.hdfs.protocol.PutResponseProto.blocks)
    return blocks_;
  }
  
  // -------------------------------------------------------------------
  
  // RmRequestProto
  
  // repeated .cn.edu.cn.tsinghua.hdfs.protocol.PathProto path = 1;
  inline int RmRequestProto::path_size() const {
    return path_.size();
  }
  inline ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* RmRequestProto::mutable_path(int index) {
    // @@protoc_insertion_point(field_mutable:cn.edu.cn.tsinghua.hdfs.protocol.RmRequestProto.path)
    return path_.Mutable(index);
  }
  inline ::google::protobuf::RepeatedPtrField< ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto >*
  RmRequestProto::mutable_path() {
    // @@protoc_insertion_point(field_mutable_list:cn.edu.cn.tsinghua.hdfs.protocol.RmRequestProto.path)
    return &path_;
  }
  inline const ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto& RmRequestProto::path(int index) const {
    // @@protoc_insertion_point(field_get:cn.edu.cn.tsinghua.hdfs.protocol.RmRequestProto.path)
    return path_.Get(index);
  }
  inline ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto* RmRequestProto::add_path() {
    // @@protoc_insertion_point(field_add:cn.edu.cn.tsinghua.hdfs.protocol.RmRequestProto.path)
    return path_.Add();
  }
  inline const ::google::protobuf::RepeatedPtrField< ::cn::edu::cn::tsinghua::hdfs::protocol::PathProto >&
  RmRequestProto::path() const {
    // @@protoc_insertion_point(field_list:cn.edu.cn.tsinghua.hdfs.protocol.RmRequestProto.path)
    return path_;
  }
  
  // -------------------------------------------------------------------
  
  // RmResponseProto
  
  // bool isSuccessful = 1;
  inline void RmResponseProto::clear_issuccessful() {
    issuccessful_ = false;
  }
  inline bool RmResponseProto::issuccessful() const {
    // @@protoc_insertion_point(field_get:cn.edu.cn.tsinghua.hdfs.protocol.RmResponseProto.isSuccessful)
    return issuccessful_;
  }
  inline void RmResponseProto::set_issuccessful(bool value) {
    
    issuccessful_ = value;
    // @@protoc_insertion_point(field_set:cn.edu.cn.tsinghua.hdfs.protocol.RmResponseProto.isSuccessful)
  }
  
  #ifdef __GNUC__
    #pragma GCC diagnostic pop
  #endif  // __GNUC__
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  
  // @@protoc_insertion_point(namespace_scope)
  
  }  // namespace protocol
  }  // namespace hdfs
  }  // namespace tsinghua
  }  // namespace cn
  }  // namespace edu
  }  // namespace cn
  
  // @@protoc_insertion_point(global_scope)
  
  #endif  // PROTOBUF_INCLUDED_ClientNamenodeProtocol_2eproto
  